Class Summary | |
---|---|
AbstractObjectCreationFactory |
Abstract base class for |
AbstractRulesImpl |
|
BeanPropertySetterRule |
Rule implements sets a bean property on the top object to the body text. The property set:
Using the second method and the ExtendedBaseRules child match pattern, all the child elements can be automatically mapped to properties on the parent object. |
CallMethodRule |
Rule implementation that calls a method on an object on the stack
(normally the top/parent object), passing arguments collected from
subsequent |
CallParamRule |
Rule implementation that saves a parameter for use by a surrounding
This parameter may be:
|
CircularIncludeException | Thrown when parsing XML into Digester rules, if a circular inclusion occurred in the xml digester rules files. |
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. |
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 from XML digester rules files. |
DigesterLoadingException | Thrown when an error occurs while parsing XML into Digester rules. |
DigesterRuleParser | This is a RuleSet that parses XML into Digester rules, and then adds those rules to a 'target' Digester. |
DigesterRuleParser.BeanPropertySetterRuleFactory | Factory for creating a BeanPropertySetterRule. |
DigesterRuleParser.CallMethodRuleFactory | Factory for creating a CallMethodRule. |
DigesterRuleParser.CallParamRuleFactory | Factory for creating a CallParamRule. |
DigesterRuleParser.FactoryCreateRuleFactory | Factory for creating a FactoryCreateRule |
DigesterRuleParser.IncludeRule | A rule for including one rules XML file within another. |
DigesterRuleParser.ObjectCreateRuleFactory | Factory for creating a ObjectCreateRule |
DigesterRuleParser.ObjectParamRuleFactory | Factory for creating a ObjectParamRule |
DigesterRuleParser.PatternRule | A rule for extracting the pattern matching strings from the rules XML. |
DigesterRuleParser.PatternStack | A stack whose toString method returns a '/'-separated concatenation of all the elements in the stack. |
DigesterRuleParser.RulesPrefixAdapter | Wraps a Rules object. |
DigesterRuleParser.SetNestedPropertiesAliasRule | A rule for adding a attribute-property alias to the custom alias mappings of the containing SetNestedPropertiesRule rule. |
DigesterRuleParser.SetNestedPropertiesRuleFactory | Factory for creating a SetNestedPropertiesRule |
DigesterRuleParser.SetNextRuleFactory | Factory for creating a SetNextRuleFactory |
DigesterRuleParser.SetPropertiesAliasRule | A rule for adding a attribute-property alias to the custom alias mappings of the containing SetPropertiesRule rule. |
DigesterRuleParser.SetPropertiesRuleFactory | Factory for creating a SetPropertiesRule |
DigesterRuleParser.SetPropertyRuleFactory | Factory for creating a SetPropertyRule |
DigesterRuleParser.SetRootRuleFactory | Factory for creating a SetRootRuleFactory |
DigesterRuleParser.SetTopRuleFactory | Factory for creating a SetTopRuleFactory |
DigesterRulesSource | Interface for classes that initialize a Digester Rules object with Digester Rules. |
ExtendedBaseRules |
Extension of RulesBase for complex schema. This is an extension of the basic pattern matching scheme intended to improve support for mapping complex xml-schema. |
FactoryCreateRule |
Rule implementation that uses an ObjectCreationFactory to create a new object which it pushes onto the object stack. |
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. |
FromXmlRuleSet | A Digester rule set where the rules come from an XML file. |
FromXmlRuleSet.InputSourceXMLRulesLoader | Loads XMLRules from an InputSource |
FromXmlRuleSet.URLXMLRulesLoader | Loads XMLRules from an URL |
FromXmlRuleSet.XMLRulesLoader | Worker class encapsulates loading mechanisms. |
GenericParser |
Create a SAXParser configured to support XML Schema and DTD.
|
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. |
MultiVariableExpander |
Expands variable references from multiple sources. |
NodeCreateRule |
A rule implementation that creates a DOM
org.w3c.dom.Node Node containing the XML at the element that matched
the rule. |
NodeCreateRule.NodeBuilder | The SAX content handler that does all the actual work of assembling the DOM node tree from the SAX events. |
ObjectCreateRule | Rule implementation that creates a new object and pushes it onto the object stack. |
ObjectCreationFactory |
Interface for use with FactoryCreateRule. |
ObjectParamRule |
Rule implementation that saves a parameter for use by a surrounding
This parameter may be:
|
ParserFeatureSetterFactory |
Creates a SAXParser based on the underlying parser.
|
PathCallParamRule |
Rule implementation that saves a parameter containing the
|
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. The regex implementation is pluggable, allowing different strategies to be used. |
RegexRules.RegisteredRule | Used to associate rules with paths in the rules list |
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 |
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. |
RuleSet |
Public interface defining a shorthand means of configuring a complete
set of related |
RuleSetBase |
Convenience base class that implements the RuleSet interface. |
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. Example input that can be processed by this rule: [widget] [height]7[/height] [width]8[/width] [label]Hello, world[/label] [/widget] For each child element of [widget], a corresponding setter method is located on the object on the top of the digester stack, the body text of the child element is converted to the type specified for the (sole) parameter to the setter method, then the setter method is invoked. This rule supports custom mapping of xml element names to property names. |
SetNestedPropertiesRule.AnyChildRule | |
SetNestedPropertiesRule.AnyChildRules | Private Rules implementation |
SetNextRule |
Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument. |
SetPropertiesRule |
Rule implementation that sets properties on the object at the top of the stack, based on attributes with corresponding names. This rule supports custom mapping of attribute names to property names. |
SetPropertyRule | Rule implementation that sets an individual property on the object at the top of the stack, based on attributes with specified names. |
SetRootRule |
Rule implementation that calls a method on the root object on the stack, passing the top object (child) as an argument. |
SetTopRule |
Rule implementation that calls a "set parent" method on the top (child) object, passing the (top-1) (parent) object as an argument. This rule now supports more flexible method matching by default. |
SimpleRegexMatcher |
Simple regex pattern matching algorithm. This uses just two wildcards:
|
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 |
This allows default |
XercesParser |
Create a SAXParser based on the underlying Xerces version.
|
XmlLoadException | Thrown when an error occurs while parsing XML into Digester rules. |