All Classes and Interfaces
Class
Description
Abstract base class for
ObjectCreationFactory
implementations.AbstractRuleImpl provides basic services for Rules implementations.An object capable of providing instances of
Rule.An object capable of providing instances of
AnnotationRuleProvider.Simple utility class to introspect annotations.
Methods arguments annotated with
AttributeCallParam will be bound
with CallParamRule digester rule.Defines several
@AttributeCallParam annotations on the same element.Provides instances of
CallParamRule.Fields annotated with
BeanPropertySetter will be bound with
BeanPropertySetterRule digester rule.Defines several
@BeanPropertySetter annotations on the same element. Rule implements sets a bean property on the top object
to the body text.
Provides instances of
BeanPropertySetterRule.Methods annotated with
CallMethod will be bound with
CallMethodRule digester rule.Defines several
@CallMethod annotations on the same element.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.Provides instances of
CallMethodRuleMethods arguments annotated with
CallParam will be bound with
CallParamRule digester rule.Defines several
@CallParam annotations on the same element.Rule implementation that saves a parameter for use by a surrounding
CallMethodRule.Provides instances of
CallParamRule.Thrown when parsing XML into Digester rules, if a circular inclusion occurred
in the xml digester rules files.
Marks a Digester rule as a creation rule, that's crucial for the
setNext rule.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.
Default
AnnotationRuleProviderFactory implementation.Default
DigesterLoaderHandlerFactory implementation.The DefaultLoaderHandler marks rules that have to be processed by the built-in
Digester annotation rules engine.
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.
This class manages the creation of Digester instances analyzing target classes
annotated with digester annotations.
This class manages the creation of Digester instances from XML digester
rules files.
DigesterLoader builder implementation.A
DigesterLoaderHandler intercept a Class visit performed by
the DigesterLoader and performs the
DigesterLoaderHandler.handle(Annotation, AnnotatedElement, FromAnnotationsRuleSet)
method.An object capable of providing instances of
DigesterLoaderHandler.The exception thrown when an error occurs while analyzing targets and
building rule sets.
Thrown when an error occurs while parsing XML into Digester rules.
Meta-annotation that marks an annotation as part of commons-digester.
Meta-annotation that marks an annotation as a list of commons-digester
annotations.
This is a RuleSet that parses XML into Digester rules, and then
adds those rules to a 'target' Digester.
Interface for classes that initialize a Digester Rules object with
Digester Rules.
Extension of
RulesBase for complex schema.Classes annotated with
FactoryCreate will be bound with
FactoryCreateRule digester rule.Defines several
@FactoryCreate annotations on the same element.Rule implementation that uses an
ObjectCreationFactory to create
a new object which it pushes onto the object stack.Provides instances of
FactoryCreateRule.A rule-finding algorithm which expects the caller to specify a classname and
methodname as plugin properties.
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.
A rule-finding algorithm which looks for a method with a specific name
on the plugin class.
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.
A rule-finding algorithm which expects the user to specify an absolute
or relative path in the plugin declaration.
A rule-finding algorithm which expects the caller to specify a methodname
as a plugin property, where the method exists on the plugin class.
A rule-finding algorithm which expects the user to specify a resource
name (ie a file in the classpath).
A rule-finding algorithm which expects the user to specify whether
"automatic property setting" is desired.
DigesterLoader builder implementation.A Digester rule set where the rules come from an XML file.
Deprecated.
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.
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.
A rule-finding algorithm which loads an xmlplugins-format file.
A RuleLoader which creates a single SetPropertiesRule and adds it to the
digester when its addRules() method is invoked.
Class to supply the missing Java
AnnotatedElement for method
arguments.Handler that takes care to create the
SetNextRuleProvider
and
SetRootRuleProvider.Expands variable references from multiple sources.
A rule implementation that creates a DOM
Node containing the XML at the element that matched
the rule.Classes annotated with
ObjectCreate will be bound with
ObjectCreateRule digester rule.Defines several
@ObjectCreate annotations on the same element.Rule implementation that creates a new object and pushes it
onto the object stack.
Provides instances of
ObjectCreateRule. Interface for use with
FactoryCreateRule.Rule implementation that saves a parameter for use by a surrounding
CallMethodRule.Deprecated.
Create an XMLParser instance yourself, configure validation
appropriately, and pass it as a parameter to the
Digester constructor, or use
Digester.setXMLSchema(javax.xml.validation.Schema) for validation.Methods arguments annotated with
PathCallParam will be bound
with PathCallParamRule digester rule.Defines several
@PathCallParam annotations on the same element.Rule implementation that saves a parameter containing the
Digester matching path for use by a surrounding
CallMethodRule.Provides instances of
PathCallParamRule.Thrown when a bug is detected in the plugins code.
Thrown when an error occurs due to the way the calling application uses
the plugins module.
Provides data and services which should exist only once per digester.
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.
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.
Thrown when some plugin-related error has occurred, and none of the
other exception types are appropriate.
Thrown when an error occurs due to bad data in the file being parsed.
Coordinates between PluginDeclarationRule and PluginCreateRule objects,
providing a place to share data between instances of these rules.
A custom digester Rules manager which must be used as the Rules object
when using the plugins module functionality.
Regular expression matching strategy for RegexRules.
Rules implementation that uses regular expression matching for paths.
Concrete implementations of this class implement actions to be taken when
a corresponding nested pattern of XML elements has been matched.
Each concrete implementation of RuleFinder is an algorithm for
locating a source of digester rules for a plugin.
Interface for classes which can dynamically load custom
plugin rules associated with a user's plugin class.
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.
Default implementation of the
Rules interface that supports
the standard rule matching behavior.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.Convenience base class that implements the
RuleSet interface.Simple in-memory LRU cache implementation.
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.
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.
Methods annotated with
SetNext will be bound
with SetNextRule digester rule.Rule implementation that calls a method on the (top-1) (parent)
object, passing the top object (child) as an argument.
Provides instances of
SetNextRule.Handler that takes care to create the
SetPropertiesRuleProvider.Rule implementation that sets properties on the object at the top of the
stack, based on attributes with corresponding names.
Provides instances of
SetPropertiesRule.Fields annotated with
SetProperty will be bound
with SetPropertiesRule digester rule.Defines several
@SetProperty annotations on the same element.Rule implementation that sets an individual property on the object at the
top of the stack, based on attributes with specified names.
Methods annotated with
SetRoot will be bound
with SetRootRule digester rule.Rule implementation that calls a method on the root object on the stack,
passing the top object (child) as an argument.
Provides instances of
SetRootRule.Methods annotated with
SetTop will be bound
with SetTopRule digester rule.Defines several
@SetTop annotations on the same elementRule implementation that calls a "set parent" method on the top (child)
object, passing the (top-1) (parent) object as an argument.
Provides instances of
SetTopRule.Simple regex pattern matching algorithm.
An interface that can be implemented in order to get notifications of
objects being pushed onto a digester stack or popped from one.
Methods arguments annotated with
StackCallParam will be bound
with CallParamRule digester rule.Defines several
StackCallParam annotations on the same element.Provides instances of
CallParamRule.(Logical) Interface for substitution strategies.
Wrapper for an org.xml.sax.Attributes object which expands any
"variables" referenced in the attribute value via ${foo} or similar.
An Interface describing a class capable of expanding strings which
may contain variable references.
Substitutor implementation that support variable replacement
for both attributes and body text.
Rules Decorator that returns default rules
when no matches are returned by the wrapped implementation.Deprecated.
Create an XMLParser instance yourself, configure validation
appropriately, and pass it as a parameter to the
Digester constructor, or use
Digester.setXMLSchema(javax.xml.validation.Schema) for validation.Thrown when an error occurs while parsing XML into Digester rules.
Digesterconstructor, or useDigester.setXMLSchema(javax.xml.validation.Schema)for validation.