All Classes and Interfaces
Class
Description
Builder invoked to back to main
LinkedRuleBuilder
.A support class for RulesModule which reduces repetition and results in a more readable configuration, that
sets rules binding for a defined namespace URI (it can be overridden while binding).
Abstract base class for
ObjectCreationFactory
implementations.Builder chained when invoking
LinkedRuleBuilder.setNext(String)
,
LinkedRuleBuilder.setRoot(String)
or LinkedRuleBuilder.setTop(String)
.AbstractRuleImpl
provides basic services for Rules
implementations.A support class for RulesModule which reduces repetition and results in a more readable configuration.
Intercepts a
Class
visit performed by
the DigesterLoader
.An object capable of providing instances of
AnnotationHandler
.Simple utility class to introspect annotations.
Fields annotated with
BeanPropertySetter
will be bound with BeanPropertySetterRule
digester rule.Defines several
@BeanPropertySetter
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.setBeanProperty()
.BeanPropertySetter
handler.
Rule implements sets a bean property on the top object to the body text.
Builder chained when invoking
LinkedRuleBuilder.addRule(Rule)
.Builder chained when invoking
LinkedRuleBuilder.addRuleCreatedBy(org.apache.commons.digester3.binder.RuleProvider)
.Methods annotated with
CallMethod
will be bound with CallMethodRule
digester rule.Defines several
@CallMethod
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.callMethod(String)
.CallMethod
handler.
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.Methods arguments annotated with
CallParam
will be bound with CallParamRule
digester rule.Defines several
@CallParam
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.callParam()
.CallParam
handler.
Rule implementation that saves a parameter for use by a surrounding
CallMethodRule.
This Substitutor chains two Substitutors
a
and b
.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
AnnotationHandlerFactory
implementation.The default Digester EDSL implementation.
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 from digester rules modules.
Thrown when errors occur while creating a
Digester
.Meta-annotation that marks an annotation as part of commons-digester.
Meta-annotation that marks an annotation as a list of commons-digester annotations.
An error message and the context in which it occurred.
Extension of
RulesBase
for complex schema.Classes annotated with
FactoryCreate
will be bound with FactoryCreateRule
digester rule.Dummy ObjectCreationFactory type - only for annotation value type purposes.
Defines several
@FactoryCreate
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.factoryCreate()
.FactoryCreate
handler.
Rule implementation that uses an
ObjectCreationFactory
to create a new object which it pushes onto the object
stack.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.
RulesModule
implementation that allows loading rules from
annotated classes.Used to associate pattern/namespaceURI
RulesModule
implementation that allows loading rules from
XML files.A rule for including one rules XML file within another.
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.
Builder invoked to bind one or more rules to a pattern.
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.
Simple utility class to assist in logging.
Class to supply the missing Java
AnnotatedElement
for method arguments.
Expands variable references from multiple sources.
Builder chained when invoking
LinkedRuleBuilder.setNestedProperties()
.A rule implementation that creates a DOM
Node
containing the XML at the element that matched
the rule.Builder chained when invoking
LinkedRuleBuilder.createNode()
.Enumeration that wraps admitted
Node
node constants.Classes annotated with
ObjectCreate
will be bound with ObjectCreateRule
digester rule.Defines several
@ObjectCreate
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.createObject()
.ObjectCreateHandler
handler.Rule implementation that creates a new object and pushes it onto the object stack.
Interface for use with
FactoryCreateRule
.Builder chained when invoking
LinkedRuleBuilder.objectParam(Object)
.
Rule implementation that saves a parameter for use by a surrounding
CallMethodRule.
Methods arguments annotated with
PathCallParam
will be bound with PathCallParamRule
digester rule.Defines several
@PathCallParam
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.callParamPath()
.PathCallParam
handler.
Rule implementation that saves a parameter containing the
Digester
matching path for use by a
surrounding CallMethodRule
.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.
Builder chained when invoking
LinkedRuleBuilder.createPlugin()
.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.
Builder chained when invoking
LinkedRuleBuilder.declarePlugin()
.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.
Detached representation of a method invocation.
Regular expression matching strategy for RegexRules.
Rules implementation that uses regular expression matching for paths.
Used to associate rules with paths in the rules list
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.
Defines a functor interface implemented by classes that perform a predicate test
An object capable of providing instances of
Rule
.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.The Digester EDSL.
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.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.
A module is the Digester rule bindings provider.
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.Builder chained when invoking
LinkedRuleBuilder.setNext(String)
.SetNext
handler.
Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an
argument.
Builder chained when invoking
LinkedRuleBuilder.setProperties()
.SetProperty
handler.
Rule implementation that sets properties on the object at the top of the stack, based on attributes with
corresponding names.
Fields annotated with
SetProperty
will be bound with SetPropertiesRule
digester rule.Defines several
@SetProperty
annotations on the same element.Builder chained when invoking
LinkedRuleBuilder.setProperty(String)
.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.Builder chained when invoking
LinkedRuleBuilder.setRoot(String)
.SetRoot
handler.
Rule implementation that calls a method on the root object on the stack, passing the top object (child) as an
argument.
Methods annotated with
SetTop
will be bound with SetTopRule
digester rule.Defines several
@SetTop
annotations on the same elementBuilder chained when invoking
LinkedRuleBuilder.setTop(String)
.SetTop
handler.
Rule implementation that calls a "set parent" method on the top (child) object, passing the (top-1) (parent) object
as an argument.
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.
(Logical) Interface for substitution strategies.
Wrapper for an
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.A
RulesBinder
implementation with memory to maintain
which classes have already been analyzed.