All Classes

Class	Description
AbstractObjectCreationFactory	Abstract base class for ObjectCreationFactory implementations.
AbstractRulesImpl	AbstractRuleImpl provides basic services for Rules implementations.
AnnotationRuleProvider<A extends java.lang.annotation.Annotation,E extends java.lang.reflect.AnnotatedElement,R extends Rule>	An object capable of providing instances of Rule.
AnnotationRuleProviderFactory	An object capable of providing instances of AnnotationRuleProvider.
AnnotationUtils	Simple utility class to introspect annotations.
AttributeCallParam	Methods arguments annotated with AttributeCallParam will be bound with CallParamRule digester rule.
AttributeCallParam.List	Defines several @AttributeCallParam annotations on the same element.
AttributeCallParamRuleProvider	Provides instances of CallParamRule.
BeanPropertySetter	Fields annotated with BeanPropertySetter will be bound with BeanPropertySetterRule digester rule.
BeanPropertySetter.List	Defines several @BeanPropertySetter annotations on the same element.
BeanPropertySetterRule	Rule implements sets a bean property on the top object to the body text.
BeanPropertySetterRuleProvider	Provides instances of BeanPropertySetterRule.
CallMethod	Methods annotated with CallMethod will be bound with CallMethodRule digester rule.
CallMethod.List	Defines several @CallMethod annotations on the same element.
CallMethodRule	Rule implementation that calls a method on an object on the stack (normally the top/parent object), passing arguments collected from subsequent CallParamRule rules or from the body of this element.
CallMethodRuleProvider	Provides instances of CallMethodRule
CallParam	Methods arguments annotated with CallParam will be bound with CallParamRule digester rule.
CallParam.List	Defines several @CallParam annotations on the same element.
CallParamRule	Rule implementation that saves a parameter for use by a surrounding CallMethodRule.
CallParamRuleProvider	Provides instances of CallParamRule.
CircularIncludeException	Thrown when parsing XML into Digester rules, if a circular inclusion occurred in the xml digester rules files.
CreationRule	Marks a Digester rule as a creation rule, that's crucial for the setNext rule.
Declaration	Represents a Class that can be instantiated by a PluginCreateRule, plus info on how to load custom digester rules for mapping xml into that plugged-in class.
DefaultAnnotationRuleProviderFactory	Default AnnotationRuleProviderFactory implementation.
DefaultDigesterLoaderHandlerFactory	Default DigesterLoaderHandlerFactory implementation.
DefaultLoaderHandler	The DefaultLoaderHandler marks rules that have to be processed by the built-in Digester annotation rules engine.
Digester	A Digester processes an XML input stream by matching a series of element nesting patterns to execute Rules that have been added prior to the start of parsing.
DigesterLoader	This class manages the creation of Digester instances analyzing target classes annotated with digester annotations.
DigesterLoader	This class manages the creation of Digester instances from XML digester rules files.
DigesterLoaderBuilder	DigesterLoader builder implementation.
DigesterLoaderHandler<A extends java.lang.annotation.Annotation,E extends java.lang.reflect.AnnotatedElement>	A DigesterLoaderHandler intercept a Class visit performed by the DigesterLoader and performs the DigesterLoaderHandler.handle(Annotation, AnnotatedElement, FromAnnotationsRuleSet) method.
DigesterLoaderHandlerFactory	An object capable of providing instances of DigesterLoaderHandler.
DigesterLoadingException	The exception thrown when an error occurs while analyzing targets and building rule sets.
DigesterLoadingException	Thrown when an error occurs while parsing XML into Digester rules.
DigesterRule	Meta-annotation that marks an annotation as part of commons-digester.
DigesterRuleList	Meta-annotation that marks an annotation as a list of commons-digester annotations.
DigesterRuleParser	This is a RuleSet that parses XML into Digester rules, and then adds those rules to a 'target' Digester.
DigesterRulesSource	Interface for classes that initialize a Digester Rules object with Digester Rules.
ExtendedBaseRules	Extension of RulesBase for complex schema.
FactoryCreate	Classes annotated with FactoryCreate will be bound with FactoryCreateRule digester rule.
FactoryCreate.List	Defines several @FactoryCreate annotations on the same element.
FactoryCreateRule	Rule implementation that uses an ObjectCreationFactory to create a new object which it pushes onto the object stack.
FactoryCreateRuleProvider	Provides instances of FactoryCreateRule.
FinderFromClass	A rule-finding algorithm which expects the caller to specify a classname and methodname as plugin properties.
FinderFromDfltClass	A rule-finding algorithm which looks for a method with a specific name on a class whose name is derived from the plugin class name.
FinderFromDfltMethod	A rule-finding algorithm which looks for a method with a specific name on the plugin class.
FinderFromDfltResource	A rule-finding algorithm which looks for a resource file in the classpath whose name is derived from the plugin class name plus a specified suffix.
FinderFromFile	A rule-finding algorithm which expects the user to specify an absolute or relative path in the plugin declaration.
FinderFromMethod	A rule-finding algorithm which expects the caller to specify a methodname as a plugin property, where the method exists on the plugin class.
FinderFromResource	A rule-finding algorithm which expects the user to specify a resource name (ie a file in the classpath).
FinderSetProperties	A rule-finding algorithm which expects the user to specify whether "automatic property setting" is desired.
FromAnnotationRuleProviderFactory	DigesterLoader builder implementation.
FromAnnotationsRuleSet	A RuleSet implementation that's able to inject Rules created with the annotations analysis.
FromXmlRuleSet	A Digester rule set where the rules come from an XML file.
FromXmlRuleSet.XMLRulesLoader	Worker class encapsulates loading mechanisms.
GenericParser	Deprecated. Create an XMLParser instance yourself, configure validation appropriately, and pass it as a parameter to the Digester constructor, or use setXMLSchema(javax.xml.validation.Schema) for validation.
InitializableRule	Defines an interface that a Rule class can implement if it wishes to get an initialisation callback after the rule has been added to the set of Rules within a PluginRules instance.
LoaderFromClass	A RuleLoader which invokes a static method on a target class, leaving that method to actually instantiate and add new rules to a Digester instance.
LoaderFromStream	A rule-finding algorithm which loads an xmlplugins-format file.
LoaderSetProperties	A RuleLoader which creates a single SetPropertiesRule and adds it to the digester when its addRules() method is invoked.
LogUtils	Simple utility class to assist in logging.
MethodArgument	Class to supply the missing Java AnnotatedElement for method arguments.
MethodHandler	Handler that takes care to create the SetNextRuleProvider and SetRootRuleProvider.
MultiVariableExpander	Expands variable references from multiple sources.
NodeCreateRule	A rule implementation that creates a DOM Node containing the XML at the element that matched the rule.
ObjectCreate	Classes annotated with ObjectCreate will be bound with ObjectCreateRule digester rule.
ObjectCreate.List	Defines several @ObjectCreate annotations on the same element.
ObjectCreateRule	Rule implementation that creates a new object and pushes it onto the object stack.
ObjectCreateRuleProvider	Provides instances of ObjectCreateRule.
ObjectCreationFactory	Interface for use with FactoryCreateRule.
ObjectParamRule	Rule implementation that saves a parameter for use by a surrounding CallMethodRule.
ParserFeatureSetterFactory	Deprecated. Create an XMLParser instance yourself, configure validation appropriately, and pass it as a parameter to the Digester constructor, or use setXMLSchema(javax.xml.validation.Schema) for validation.
PathCallParam	Methods arguments annotated with PathCallParam will be bound with PathCallParamRule digester rule.
PathCallParam.List	Defines several @PathCallParam annotations on the same element.
PathCallParamRule	Rule implementation that saves a parameter containing the Digester matching path for use by a surrounding CallMethodRule.
PathCallParamRuleProvider	Provides instances of PathCallParamRule.
PluginAssertionFailure	Thrown when a bug is detected in the plugins code.
PluginConfigurationException	Thrown when an error occurs due to the way the calling application uses the plugins module.
PluginContext	Provides data and services which should exist only once per digester.
PluginCreateRule	Allows the original rules for parsing the configuration file to define points at which plugins are allowed, by configuring a PluginCreateRule with the appropriate pattern.
PluginDeclarationRule	A Digester rule which allows the user to pre-declare a class which is to be referenced later at a plugin point by a PluginCreateRule.
PluginException	Thrown when some plugin-related error has occurred, and none of the other exception types are appropriate.
PluginInvalidInputException	Thrown when an error occurs due to bad data in the file being parsed.
PluginManager	Coordinates between PluginDeclarationRule and PluginCreateRule objects, providing a place to share data between instances of these rules.
PluginRules	A custom digester Rules manager which must be used as the Rules object when using the plugins module functionality.
RegexMatcher	Regular expression matching strategy for RegexRules.
RegexRules	Rules implementation that uses regular expression matching for paths.
Rule	Concrete implementations of this class implement actions to be taken when a corresponding nested pattern of XML elements has been matched.
RuleFinder	Each concrete implementation of RuleFinder is an algorithm for locating a source of digester rules for a plugin.
RuleLoader	Interface for classes which can dynamically load custom plugin rules associated with a user's plugin class.
Rules	Public interface defining a collection of Rule instances (and corresponding matching patterns) plus an implementation of a matching policy that selects the rules that match a particular pattern of nested elements discovered during parsing.
RulesBase	Default implementation of the Rules interface that supports the standard rule matching behavior.
RuleSet	Public interface defining a shorthand means of configuring a complete set of related Rule definitions, possibly associated with a particular namespace URI, in one operation.
RuleSetBase	Convenience base class that implements the RuleSet interface.
RuleSetCache	Simple in-memory LRU cache implementation.
RulesFactory	Whenever the scope of a plugin tag is entered, the PluginRules class creates a new Rules instance and configures it with the appropriate parsing rules for the plugged-in class.
SetNestedPropertiesRule	Rule implementation that sets properties on the object at the top of the stack, based on child elements with names matching properties on that object.
SetNext	Methods annotated with SetNext will be bound with SetNextRule digester rule.
SetNextRule	Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument.
SetNextRuleProvider	Provides instances of SetNextRule.
SetPropertiesLoaderHandler	Handler that takes care to create the SetPropertiesRuleProvider.
SetPropertiesRule	Rule implementation that sets properties on the object at the top of the stack, based on attributes with corresponding names.
SetPropertiesRuleProvider	Provides instances of SetPropertiesRule.
SetProperty	Fields annotated with SetProperty will be bound with SetPropertiesRule digester rule.
SetProperty.List	Defines several @SetProperty annotations on the same element.
SetPropertyRule	Rule implementation that sets an individual property on the object at the top of the stack, based on attributes with specified names.
SetRoot	Methods annotated with SetRoot will be bound with SetRootRule digester rule.
SetRootRule	Rule implementation that calls a method on the root object on the stack, passing the top object (child) as an argument.
SetRootRuleProvider	Provides instances of SetRootRule.
SetTop	Methods annotated with SetTop will be bound with SetTopRule digester rule.
SetTop.List	Defines several @SetTop annotations on the same element
SetTopRule	Rule implementation that calls a "set parent" method on the top (child) object, passing the (top-1) (parent) object as an argument.
SetTopRuleProvider	Provides instances of SetTopRule.
SimpleRegexMatcher	Simple regex pattern matching algorithm.
StackAction	An interface that can be implemented in order to get notifications of objects being pushed onto a digester stack or popped from one.
StackCallParam	Methods arguments annotated with StackCallParam will be bound with CallParamRule digester rule.
StackCallParam.List	Defines several StackCallParam annotations on the same element.
StackCallParamRuleProvider	Provides instances of CallParamRule.
Substitutor	(Logical) Interface for substitution strategies.
VariableAttributes	Wrapper for an org.xml.sax.Attributes object which expands any "variables" referenced in the attribute value via ${foo} or similar.
VariableExpander	An Interface describing a class capable of expanding strings which may contain variable references.
VariableSubstitutor	Substitutor implementation that support variable replacement for both attributes and body text.
WithDefaultsRulesWrapper	Rules Decorator that returns default rules when no matches are returned by the wrapped implementation.
XercesParser	Deprecated. Create an XMLParser instance yourself, configure validation appropriately, and pass it as a parameter to the Digester constructor, or use setXMLSchema(javax.xml.validation.Schema) for validation.
XmlLoadException	Thrown when an error occurs while parsing XML into Digester rules.