Abstract base class for ObjectCreationFactory
implementations.
AbstractRuleImpl
provides basic services for Rules
implementations.
Adds a rule the the target digester.
Registers a new Rule instance matching the specified pattern.
Register a new Rule instance matching a pattern which is constructed
by concatenating the pattern prefix with the given pattern.
Register a new Rule instance matching the specified pattern.
Register a new Rule instance matching the specified pattern.
Register a new Rule instance matching the specified pattern.
Register a new Rule instance matching the specified pattern.
Register a new Rule instance matching the specified pattern.
Adds a Rule to be fired on given pattern.
Add an additional element name to property name mapping.
Add an additional attribute name to property name mapping.
Add a "bean property setter" rule for the specified parameters.
Add a "bean property setter" rule for the specified parameters.
Add an "call method" rule for a method which accepts no arguments.
Add an "call method" rule for the specified parameters.
Add an "call method" rule for the specified parameters.
Add a "call parameter" rule for the specified parameters.
Add a "call parameter" rule.
Add a "call parameter" rule that sets a parameter from the stack.
Add a "call parameter" rule for the specified parameters.
Add a "call parameter" rule that sets a parameter from the current
Digester
matching path.
Add the declaration to the set of known declarations.
Adds a rule to be fired when wrapped implementation returns no matches
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add a "factory create" rule for the specified parameters.
Add an "object create" rule for the specified parameters.
Add an "object create" rule for the specified parameters.
Add an "object create" rule for the specified parameters.
Add an "object create" rule for the specified parameters.
Add a "call parameter" rule that sets a parameter from a
caller-provided object.
Register a new Rule matching the specified pattern.
Add to the given digester the set of Rule instances used to parse an XML
document defining Digester rules.
Adds to the digester the set of Rule instances defined in the
XML file for this rule set.
Add the set of Rule instances defined in this RuleSet to the
specified Digester
instance, associating them with
our namespace URI (if any).
Add the set of Rule instances defined in this RuleSet to the
specified Digester
instance, associating them with
our namespace URI (if any).
Adds to the digester the set of Rule instances defined in the
XML file for this rule set.
Just invoke the target method.
Add the rules previously loaded from the input stream into the
specified digester.
Just add a SetPropertiesRule at the specified path.
Configures the digester with custom rules for some plugged-in
class.
Register a set of Rule instances defined in a RuleSet.
Add a "set next" rule for the specified parameters.
Add a "set next" rule for the specified parameters.
Add a "set properties" rule for the specified parameters.
Add a "set properties" rule with a single overridden parameter.
Add a "set properties" rule with overridden parameters.
Add a "set property" rule for the specified parameters.
Add a "set top" rule for the specified parameters.
Add a "set top" rule for the specified parameters.
All rules (preserves order in which they were originally added)
Private Rules implementation
The attribute from which to save the parameter value
The attribute containing an override class name if it is present.
The attribute containing an override class name if it is present.
The attribute which we are attempting to match
Attribute names used to override natural attribute->property mapping
The expander to be used to expand variables in the attributes.
A base class that any plugin must derive from.
Rule implements sets a bean property on the top object
to the body text.
Construct rule that automatically sets a property from the body text.
Construct rule that automatically sets a property from the body text.
Construct rule that sets the given property from the body text.
Construct rule that sets the given property from the body text.
Factory for creating a BeanPropertySetterRule.
Process the start of this element.
Process the start of this element.
To include a rules xml file, we instantiate another Digester, and
another DigesterRulesRuleSet.
If a pattern is defined for the attribute, push it onto the
pattern stack.
Add the alias to the SetPropertiesRule object created by the
enclosing tag.
Process the beginning of this element.
This method is called when the beginning of a matching XML element
is encountered.
Process the beginning of this element.
Process the beginning of this element.
Process the beginning of this element.
Process the start of this element.
Process the start of this element.
This method is called when the beginning of a matching XML element
is encountered.
Process the beginning of this element.
Invoked when the Digester matches this rule against an xml element.
Invoked upon reading a tag defining a plugin declaration.
Process the body text of this element.
Process the body text of this element.
This method is called when the body of a matching XML element
is encountered.
This is only invoked after all child elements have been processed,
so we can remove the custom Rules object that does the
child-element-matching.
Process the body text of this element.
Process the body text of this element.
This method is called when the body of a matching XML element is
encountered.
The body text used to set the property.
The body text collected from this element.
The body text of the current element.
The expander to be used to expand variables in the body text.
The stack of body text string buffers for surrounding elements.
Stack is used to allow nested body text to be processed.
The set of registered Rule instances, keyed by the matching pattern.
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.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name and
parameter types.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name.
Construct a "call method" rule with the specified method name and
parameter types.
Factory for creating a CallMethodRule.
Rule implementation that saves a parameter for use by a surrounding
CallMethodRule
.
Construct a "call parameter" rule that will save the body text of this
element as the parameter value.
Construct a "call parameter" rule.
Constructs a "call parameter" rule which sets a parameter from the stack.
Construct a "call parameter" rule that will save the value of the
specified attribute as the parameter value.
Construct a "call parameter" rule that will save the body text of this
element as the parameter value.
Construct a "call parameter" rule that will save the value of the
specified attribute as the parameter value.
Factory for creating a CallParamRule.
Process notification of character data received from the body of
an XML element.
Appends a Text
node to the current node.
Thrown when parsing XML into Digester rules, if a circular inclusion occurred
in the xml digester rules files.
The class loader to use for instantiating application objects.
The Java class name of the ObjectCreationFactory to be created.
The Java class name of the object to be created.
Clear all existing Rule instance registrations.
Clear the current contents of the object stack.
This method passes through to the underlying Rules object.
Clear all existing Rule instance registrations.
Clear all existing Rule instance registrations.
Clear all existing Rule instance registrations.
Clear all existing Rule instance registrations.
Provide a hook for lazy configuration of this Digester
instance.
Attempt to load custom rules for the target class at the specified
pattern.
Has this Digester been configured yet.
Configure schema validation as recommended by the JAXP 1.2 spec.
Configure schema validation as recommended by the Xerces spec.
Counts the entry number for the rules.
Creates a new digester and initializes it from the specified InputSource
Creates a new digester and initializes it from the specified InputSource.
Creates a new digester and initializes it from the specified XML file
Creates a new digester and initializes it from the specified XML file.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Factory method called by
FactoryCreateRule
to supply an
object based on the element's attributes.
Create a SAX exception which also understands about the location in
the digester file where the exception occurs
Create a SAX exception which also understands about the location in
the digester file where the exception occurs
Create a SAX exception which also understands about the location in
the digester file where the exception occurs
The object creation factory we will use to instantiate objects
as required based on the attributes specified in the matched XML
element.
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.
Create an instance where a fully-initialised ruleLoader instance
is provided by the caller instead of having the PluginManager
"discover" an appropriate one.
Map of classname->Declaration
The rules implementation that we are "enhancing" with plugins
functionality, as per the Decorator pattern.
Info about optional default plugin to be used if no plugin-id is
specified in the input data.
Rules to be fired when the wrapped implementations returns none.
Depth of the current node, relative to the element where the content
handler was put into action.
Xml attribute that needs to be present on a plugin declaration
in order to specify the file to load rules from.
Xml attribute that needs to be present on a plugin declaration
in order to specify the method to load rules from.
Name of xml attribute on the plugin declaration which is used
to configure rule-loading for that declaration.
The associated
Digester
instance that was set up by
FactoryCreateRule
upon initialization.
Digester using this Rules
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.
The Digester instance with which this Rules instance is associated.
The Digester with which this Rule is associated.
The Digester instance with which this Rules instance is associated.
Construct a new Digester with default properties.
Construct a new Digester, allowing a SAXParser to be passed in.
Construct a new Digester, allowing an XMLReader to be passed in.
This class manages the creation of Digester instances from XML digester
rules files.
Thrown when an error occurs while parsing XML into Digester rules.
This is a RuleSet that parses XML into Digester rules, and then
adds those rules to a 'target' Digester.
Constructs a DigesterRuleParser.
Constructs a rule set for converting XML digester rule descriptions
into Rule objects, and adding them to the given Digester
Constructs a rule set for parsing an XML digester rule file that
has been included within an outer XML digester rule file.
Interface for classes that initialize a Digester Rules object with
Digester Rules.
A DOM Document used to create the various Node instances.
The JAXP DocumentBuilder
to use.
Process the end of this element.
If there was a pattern for this element, pop it off the pattern
stack.
Pop the Node off the top of the stack.
Process the end of this element.
end() - method in class org.apache.commons.digester.
Rule This method is called when the end of a matching XML element
is encountered.
Process the end of this element.
Process the end of this element.
Process the end of this element.
Process the end of this element.
Process any body texts now.
Process the end of this element.
Invoked by the digester when the closing tag matching this Rule's
pattern is encountered.
This method is called when the end of a matching XML element
is encountered.
Process notification of the end of the document being reached.
Process notification of the end of an XML element being reached.
Checks whether control needs to be returned to Digester.
Process notification that a namespace prefix is going out of scope.
The EntityResolver used by the SAX parser.
The URLs of entityValidator that have been registered, keyed by the public
identifier that corresponds.
Forward notification of a parsing error to the application supplied
error handler (if any).
The application-supplied error handler that is notified when parsing
warnings, errors, or fatal errors occur.
Return the input string with any variables replaced by their
corresponding value.
Replace any occurrences within the string of the form
"marker{key}" with the value from source[key].
The SAXParserFactory that is created the first time we need it.
Rule implementation that uses an
ObjectCreationFactory
to create
a new object which it pushes onto the object stack.
Construct a factory create rule that will use the specified
class to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Construct a factory create rule that will use the specified
class (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Construct a factory create rule that will use the specified
class to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Construct a factory create rule that will use the specified
class name to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class name (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Construct a factory create rule that will use the specified
class name to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class name to create an
ObjectCreationFactory
which will
then be used to create an object and push it on the stack.
Construct a factory create rule that will use the specified
class name (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Construct a factory create rule that will use the specified
class name (possibly overridden by the specified attribute if present)
to create an
ObjectCreationFactory
, which will then be used
to instantiate an object instance and push it onto the stack.
Factory for creating a FactoryCreateRule
Forward notification of a fatal parsing error to the application
supplied error handler (if any).
A rule-finding algorithm which expects the caller to specify a classname and
methodname as plugin properties.
Create a rule-finder which invokes a user-specified method on a
user-specified class whenever dynamic rules for a plugin need to be
loaded.
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.
Create a rule-finder which invokes a method on a class whenever
dynamic rules for a plugin need to be loaded.
A rule-finding algorithm which looks for a method with a specific name
on the plugin class.
Create a rule-finder which invokes a specific method on the plugin
class whenever dynamic rules for a plugin need to be loaded.
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.
Create a rule-finder which can load an xmlrules file, cache
the rules away, and later add them as a plugin's custom rules
when that plugin is referenced.
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.
Create a rule-finder which will arrange for a SetPropertiesRule to
be defined for each instance of a plugin, so that xml attributes
map to bean properties.
Finds an exact ancester match for given pattern
If there exists a property with the name matching constructor param
ruleClassAttr, then load the specified class, locate the appropriate
rules-adding method on that class, and return an object encapsulating
that info.
If there exists a class whose name is the plugin class name + the
suffix specified to the constructor, then load that class, locate
the appropriate rules-adding method on that class, and return an
object encapsulating that info.
If there exists on the plugin class a method with name matching the
constructor's methodName value then locate the appropriate Method on
the plugin class and return an object encapsulating that info.
If there exists a resource file whose name is equal to the plugin
class name + the suffix specified in the constructor, then
load that file, run it through the xmlrules module and return an object
encapsulating those rules.
If there exists a property with the name specified in the constructor,
then load that file, run it through the xmlrules module and return an
object encapsulating those rules.
If there exists a property with the name matching constructor param
methodAttr, then locate the appropriate Method on the plugin class
and return an object encapsulating that info.
If there exists a property with the name matching constructor param
resourceAttr, then load that file, run it through the xmlrules
module and return an object encapsulating those rules.
Returns a RuleLoader unless the properties contain an entry
with the name matching constructor param propsAttr, and the value
matching what is in falseval.
Apply the finder algorithm to attempt to locate a source of
digester rules for the specified plugin class.
Given a plugin class and some associated properties, scan the
list of known RuleFinder instances until one detects a source of
custom rules for this plugin (aka a RuleLoader).
Return the currently mapped namespace URI for the specified prefix,
if any; otherwise return null
.
Clean up after parsing is complete.
Clean up after parsing is complete.
Clean up after parsing is complete.
This method is called after all parsing methods have been
called, to allow Rules to remove temporary data.
Duplicate the processing that the Digester does when firing the
begin methods of rules.
Duplicate the processing that the Digester does when firing the
body methods of rules.
Duplicate the processing that the Digester does when firing the
end methods of rules.
Is the parameter to be set from the stack?
A Digester rule set where the rules come from an XML file.
Constructs a FromXmlRuleSet using the default DigesterRuleParser and
rulesDigester.
Constructs a FromXmlRuleSet using the default DigesterRuleParser and
a ruleDigester for loading the rules xml.
Constructs a FromXmlRuleSet using the default DigesterRuleParser and
rulesDigester.
Constructs a FromXmlRuleSet using the default DigesterRuleParser and
a ruleDigester for loading the rules xml.
Create a SAXParser
configured to support XML Schema and DTD.
Returns the cause of this throwable or null if the cause is
nonexistent or unknown.
Return the class loader to be used for instantiating application objects
when required.
Return the current depth of the element stack.
Return the name of the XML element that is currently being processed.
Return the debugging detail level of our currently enabled logger.
Return the declaration object with the specified class.
Return the declaration object with the specified id.
This package-scope method is used by the PluginCreateRule class to
get direct access to the rules that were dynamically added by the
plugin.
Gets Rule's which will be fired when the wrapped implementation returns no matches
Return the Digester instance with which this Rules instance is
associated.
This method passes through to the underlying Rules object.
Return the Digester instance with which this instance is associated.
Return the Digester with which this Rule is associated.
Return the Digester instance with which this Rules instance is
associated.
Return the Digester instance with which this Rules instance is
associated.
Return the Digester instance with which this Rules instance is
associated.
Gets digester using these Rules
Returns the location of the DTD used to validate the digester rules
XML document.
Gets the document locator associated with our parser.
Return the Entity Resolver used by the SAX parser.
Return the error handler for this Digester.
Return the SAXParserFactory we will use, creating one if necessary.
Return an instance of our associated object creation factory,
creating one if necessary.
Returns a flag indicating whether the requested feature is supported
by the underlying implementation of org.xml.sax.XMLReader
.
Return the id associated with this declaration.
Gets the Log
implementation.
Return the current Logger associated with this instance of the Digester
Get the Log object associated with the specified Digester instance,
or a "no-op" logging object if the digester reference is null.
Return the current rule match path
Return the "namespace aware" flag for parsers we create.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
This method passes through to the underlying Rules object.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
Return the namespace URI for which this Rule is relevant, if any.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
Return the namespace URI that will be applied to all Rule instances
created from this RuleSet.
Return the namespace URI that will be applied to all Rule instances
created from this RuleSet.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
Gets namespace to apply to Rule's added
Return the parent Rules object.
Return the SAXParser we will use to parse the input stream.
Return the pattern that this Rule is associated with.
Return plugin class associated with this declaration.
Get the namespace for the xml attribute which indicates to a
PluginCreateRule which class is to be plugged in.
Get the namespace for the xml attribute which indicates to a
PluginCreateRule which class is to be plugged in.
Get the namespace for the xml attribute which indicates to a
PluginCreateRule which previous plugin declaration should be used.
Get the namespace for the xml attribute which indicates to a
PluginCreateRule which previous plugin declaration should be used.
Return the object which "knows" about all declared plugins.
Return the current value of the specified property for the underlying
XMLReader
implementation.
Return the public identifier of the DTD we are currently
parsing under, if any.
By setting the reader in the constructor, you can bypass JAXP and
be able to use digester in Weblogic 6.0.
Gets the current regex matching strategy.
Return the set of DTD URL registrations, keyed by public identifier.
When the Digester is being used as a SAXContentHandler,
this method allows you to access the root object that has been
created after parsing.
Return the list of RuleFinder objects.
Return the namespace URI that will be applied to all subsequently
added Rule
objects.
Return the Rules
implementation object containing our
rules collection and associated matching policy.
Creates and adds Digester Rules to a given Rules object
Return the set of rules that apply to the specified match position.
Gets the logger used for logging SAX-related information.
Return the XML Schema URI used for validating an XML instance.
Return the XML Schema language used when parsing.
Gets the Substitutor
used to convert attributes and body text.
Return the boolean as to whether the context classloader should be used.
Should MethodUtils.invokeExactMethod
be used for the reflection.
Return the validating parser flag.
Return the current Xerces version.
Return the XMLReader to be used for parsing the input document.
The contents of the input stream are loaded into memory, and
cached for later use.
Given the digester rules XML file, a class loader, and an input stream,
this method parses the input into Java objects.
Given the digester rules XML file, a class loader, and an input stream,
this method parses the input into Java objects.
Given the digester rules XML file, a class loader, and an input stream,
this method parses the input into Java objects.
Given the digester rules XML file, a class loader, and an input stream,
this method parses the input into Java objects.
Given the digester rules XML file, a class loader, and an XML input file,
this method parses the input file into Java objects.
Given the digester rules XML file, a class loader, and an XML input file,
this method parses the input file into Java objects.
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.
Open the specified resource file (ie a file in the classpath,
including being within a jar in the classpath), run it through
the xmlrules module and return an object encapsulating those rules.
Find a method on the specified class whose name matches methodName,
and whose signature is:
public static void foo(Digester d, String patternPrefix);
.
The Locator associated with our parser.
log - field in class org.apache.commons.digester.
Digester The Log to which most logging calls will be made.
The Log to which all SAX event related logging calls will be made.
Custom log (can be set per object)
log - static field in class org.apache.commons.digester.parser.
XercesParser The Log to which all SAX event related logging calls will be made.
Log a message to our associated logger.
Log a message and exception to our associated logger.
Simple utility class to assist in logging.
Return a List of Rule instances for the specified pattern that also
match the specified namespace URI (if any).
The current match pattern for nested element processing.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
This method passes through to the underlying Rules object.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nodepath, or a zero-length List if there are no matches.
Returns true if the given pattern matches the given path
according to the regex algorithm that this strategy applies.
Finds matching rules by using current regex matching strategy.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Return a List of all registered Rule instances that match the specified
nesting pattern, or a zero-length List if there are no matches.
Matches using simple regex algorithm.
Return list of rules matching given pattern.
Implementation of regex matching algorithm.
The regex strategy used by this RegexRules
Stack whose elements are List objects, each containing a list of
Rule objects as returned from Rules.getMatch().
The method name to call on the parent object.
The method name to call on the parent object.
The method name to call on the parent object.
The method name to call on the child object.
The path below which this rules object has responsibility.
Expands variable references from multiple sources.
Rule implementation that creates a new object and pushes it
onto the object stack.
Construct an object create rule with the specified class.
Construct an object create rule with the specified class.
Construct an object create rule with the specified class name.
Construct an object create rule with the specified class and an
optional attribute name containing an override.
Construct an object create rule with the specified class name and an
optional attribute name containing an override.
Construct an object create rule with the specified class name.
Construct an object create rule with the specified class and an
optional attribute name containing an override.
Construct an object create rule with the specified class name and an
optional attribute name containing an override.
Factory for creating a ObjectCreateRule
Rule implementation that saves a parameter for use by a surrounding
CallMethodRule
.
Construct a "call parameter" rule that will save the given Object as
the parameter value.
Construct a "call parameter" rule that will save the given Object as
the parameter value, provided that the specified attribute exists.
Factory for creating a ObjectParamRule
The content handler used by Digester before it was set to this
content handler.
The decision algorithm used (unfortunately) doesn't preserve the entry
order.
The Digester package provides for rules-based processing of arbitrary
XML documents.
Provides for parser recognition and parser dependent code.
Provides an easy mechanism whereby new digestion rules
can be added dynamically during a digestion.
This package contains "rule-finding" strategy classes, and their associated
"helper" loader classes.
Provides for manipulation of xml attributes and element body text before
the data is processed by any Rule objects.
The xmlrules
package provides for XML-based definition of
rules for Digester
.
The parameter we wish to pass to the method call
The names of the classes of the parameters to be collected.
The number of parameters to collect from MethodParam
rules.
The zero-relative index of the parameter we are saving.
The zero-relative index of the parameter we are saving.
The zero-relative index of the parameter we are saving.
The parameters stack being utilized by CallMethodRule and
CallParamRule rules.
The Java class name of the parameter type expected by the method.
The Java class name of the parameter type expected by the method.
The Java class name of the parameter type expected by the method.
The parameter types of the parameters to be collected.
the parent manager to which this one may delegate lookups.
The Rules object that holds rules applying "above" the mountpoint,
ie the next Rules object down in the stack.
Parse the content of the specified file using this Digester.
Parse the content of the specified input source using this Digester.
Parse the content of the specified input stream using this Digester.
Parse the content of the specified reader using this Digester.
Parse the content of the specified URI using this Digester.
The SAXParser we will use to parse the input stream.
The rule set for parsing the Digester rules
Creates a SAXParser
based on the underlying parser.
Rule implementation that saves a parameter containing the
Digester
matching path for use by a surrounding
CallMethodRule
.
Construct a "call parameter" rule that will save the body text of this
element as the parameter value.
In order to invoke the addRules method on the plugin class correctly,
we need to know the pattern which this rule is matched by.
A rule for extracting the pattern matching strings from the rules XML.
A stack whose toString method returns a '/'-separated concatenation
of all the elements in the stack.
Return the top object on the stack without removing it.
Return the n'th object down the stack, where 0 is the top element
and [getCount()-1] is the bottom element.
Gets the top object from the stack with the given name.
Return the top object on the parameters stack without removing it.
Return the n'th object down the parameters stack, where 0 is the top element
and [getCount()-1] is the bottom element.
Thrown when a bug is detected in the plugins code.
The class of the object to be instantiated.
The name of the class of the object to be instantiated.
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.
The object containing data that should only exist once for each
Digester instance.
A reference to the object that holds all data which should only
exist once per digester instance.
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.
Create a plugin rule where the user must specify a plugin-class
or plugin-id.
Create a plugin rule where the user may specify a plugin.
Create a plugin rule where the user may specify a plugin.
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.
Object which contains information about all known plugins.
Construct a "root" PluginManager, ie one with no parent.
Construct a "child" PluginManager.
A custom digester Rules manager which must be used as the Rules object
when using the plugins module functionality.
Constructor for top-level Rules objects.
Constructor for top-level Rules object which handles rule-matching
using the specified implementation.
Constructs a Rules instance which has a parent Rules object
(which is different from having a delegate rules object).
Pop the top object off of the stack, and return it.
Pops (gets and removes) the top object from the stack with the given name.
Pop the top object off of the parameters stack, and return it.
Called after this Rule object has been added to the list of all Rules.
Invoked after this rule has been added to the set of digester rules,
associated with the specified pattern.
Process notification of a processing instruction that was encountered.
Adds a new
ProcessingInstruction
to
the current node.
Subclasses may override this method to perform additional processing of the
invoked method's result.
Dummy object that can be placed in collections to indicate an
ignored property when null cannot be used for that purpose.
Set this property on the top object.
Property names used to override natural attribute->property mapping
The public identifier of the DTD we are currently parsing under
(if any).
Push a new object onto the top of the object stack.
Pushes the given object onto the stack with the given name.
Push a new object onto the top of the parameters stack.
The XMLReader used to parse digester rules.
Regular expression matching strategy for RegexRules.
Rules implementation that uses regular expression matching for paths.
Construct sets the Regex matching strategy.
Register the specified DTD URL for the specified public identifier.
Used to associate rules with paths in the rules list
Register rule at given pattern.
Register a new Rule instance matching the specified pattern.
Resolve the requested external entity.
The "root" element of the stack (in other words, the last object
that was popped.
The DOM node that will be pushed on Digester's stack.
Rule - class org.apache.commons.digester.
Rule Concrete implementations of this class implement actions to be taken when
a corresponding nested pattern of XML elements has been matched.
Rule() - constructor for class org.apache.commons.digester.
Rule Base constructor.
Constructor sets the associated Digester.
Each concrete implementation of RuleFinder is an algorithm for
locating a source of digester rules for a plugin.
A list of RuleFinder objects used by all Declarations (and thus
indirectly by all PluginCreateRules to locate the custom rules
for plugin classes.
Class which is responsible for dynamically loading this
plugin's rules on demand.
Interface for classes which can dynamically load custom
plugin rules associated with a user's plugin class.
The Rules
implementation containing our collection of
Rule
instances and associated matching policy.
Rules - interface org.apache.commons.digester.
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.
The set of registered Rule instances, in the order that they were
originally registered.
Return a List of all registered Rule instances, or a zero-length List
if there are no registered Rule instances.
This method passes through to the underlying Rules object.
Return the list of rules registered with this object, in the order
they were registered with this object.
Return a List of all registered Rule instances, or a zero-length List
if there are no registered Rule instances.
Return a List of all registered Rule instances, or a zero-length List
if there are no registered Rule instances.
Return a List of all registered Rule instances, or a zero-length List
if there are no registered Rule instances.
Return a List of all registered Rule instances, or a zero-length List
if there are no registered Rule instances.
Default implementation of the Rules
interface that supports
the standard rule matching behavior.
The digester for loading the rules xml.
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.
The file containing the Digester rules, in XML.
The Log to which all SAX event related logging calls will be made.
The XML schema language to use for validating an XML instance.
The XML schema to use for validating an XML instance.
When set to true, any child element for which there is no
corresponding object property will cause an error to be reported.
Set a base pattern beneath which all the rules loaded by this
object will be registered.
Set the class loader to be used for instantiating application objects
when required.
Set the debugging detail level of our currently enabled logger.
Set the
Digester
to allow the implementation to do logging,
classloading based on the digester's classloader, etc.
Set the Digester instance with which this Rules instance is associated.
Set the associated digester.
This method passes through to the underlying Rules object.
Set the
Digester
to allow the implementation to do logging,
classloading based on the digester's classloader, etc.
Set the Digester instance with which this Rules instance is associated.
Set the Digester
with which this Rule
is associated.
Set the Digester instance with which this Rules instance is associated.
Set the Digester instance with which this Rules instance is associated.
Invoked when rule is added to digester.
Set the Digester instance with which this Rules instance is associated.
Sets digeseter using these Rules
Sets the location of the digester rules DTD.
Sets the document locator associated with our parser.
Set the EntityResolver
used by SAX when resolving
public id and system id.
Set the error handler for this Digester.
Set whether exact matching is enabled.
Set whether exact matching is enabled.
Set whether exact matching is enabled.
Sets a flag indicating whether the requested feature is supported
by the underlying implementation of org.xml.sax.XMLReader
.
The id that the user associated with a particular plugin declaration
in the input xml.
Sets the current Log
implementation used by this class.
Set the current logger for this Digester.
Set the "namespace aware" flag for parsers we create.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
This method passes through to the underlying Rules object.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
Set the namespace URI for which this Rule is relevant, if any.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
Sets namespace to apply to Rule's added subsequently
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.
Convenience constructor overrides the mapping for just one property.
Constructor allows element->property mapping to be overriden.
Rule implementation that calls a method on the (top-1) (parent)
object, passing the top object (child) as an argument.
Construct a "set next" rule with the specified method name.
Construct a "set next" rule with the specified method name.
Construct a "set next" rule with the specified method name.
Construct a "set next" rule with the specified method name.
Factory for creating a SetNextRuleFactory
Sets the xml attribute which the input xml uses to indicate to a
PluginCreateRule which class should be instantiated.
Sets the xml attribute which the input xml uses to indicate to a
PluginCreateRule which class should be instantiated.
Sets the xml attribute which the input xml uses to indicate to a
PluginCreateRule which plugin declaration is being referenced.
Sets the xml attribute which the input xml uses to indicate to a
PluginCreateRule which plugin declaration is being referenced.
Copy all (key,value) pairs in the param into the properties member of
this object.
A rule for adding a attribute-property alias to the custom alias mappings of
the containing SetPropertiesRule rule.
Rule implementation that sets properties on the object at the top of the
stack, based on attributes with corresponding names.
Default constructor sets only the the associated Digester.
Convenience constructor overrides the mapping for just one property.
Constructor allows attribute->property mapping to be overriden.
Factory for creating a SetPropertiesRule
Set the current value of the specified property for the underlying
XMLReader
implementation.
Rule implementation that sets an individual property on the object at the
top of the stack, based on attributes with specified names.
Construct a "set property" rule with the specified name and value
attributes.
Construct a "set property" rule with the specified name and value
attributes.
Factory for creating a SetPropertyRule
Set the publid id of the current file being parse.
Sets the current regex matching strategy.
Rule implementation that calls a method on the root object on the stack,
passing the top object (child) as an argument.
Construct a "set root" rule with the specified method name.
Construct a "set root" rule with the specified method name.
Construct a "set root" rule with the specified method name.
Construct a "set root" rule with the specified method name.
Factory for creating a SetRootRuleFactory
Set the list of RuleFinder objects.
Set the namespace URI that will be applied to all subsequently
added Rule
objects.
Set the Rules
implementation object containing our
rules collection and associated matching policy.
Sets the logger used for logging SAX-related information.
Set the XML Schema URI used for validating a XML Instance.
Set the XML Schema language used when parsing.
Sets the Substitutor
to be used to convert attributes and body text.
Sets the digester into which to add the parsed rules
Rule implementation that calls a "set parent" method on the top (child)
object, passing the (top-1) (parent) object as an argument.
Construct a "set parent" rule with the specified method name.
Construct a "set parent" rule with the specified method name.
Construct a "set parent" rule with the specified method name.
Construct a "set parent" rule with the specified method name.
Factory for creating a SetTopRuleFactory
When set to true, any text within child elements will have leading
and trailing whitespace removed before assignment to the target
object.
Determine whether to use the Context ClassLoader (the one found by
calling Thread.currentThread().getContextClassLoader()
)
to resolve/load classes that are defined in various rules.
Set whether MethodUtils.invokeExactMethod
should be used for the reflection.
Set the validating parser flag.
Simple regex pattern matching algorithm.
Process notification of a skipped entity.
The object stack being constructed.
The position of the object from the top of the stack
Stacks used for interrule communication, indexed by name String
Process notification of the beginning of the document being reached.
Process notification of the start of an XML element being reached.
Adds a new child Element
to the current
node.
Process notification that a namespace prefix is coming in to scope.
Substitutes the attributes (before they are passed to the
Rule
implementations's).
Substitutes the attributes (before they are passed to the
Rule
implementations's)
Substitutes for the body text.
Substitutes for the body text.
An optional class that substitutes values in attributes and body text.
(Logical) Interface for substitution strategies.