You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by si...@apache.org on 2011/05/12 20:03:33 UTC
svn commit: r1102402 [12/20] - in /commons/sandbox/digester3/trunk/src:
main/java/org/apache/commons/digester3/
main/java/org/apache/commons/digester3/annotations/
main/java/org/apache/commons/digester3/annotations/handlers/
main/java/org/apache/common...
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRuleParser.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRuleParser.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRuleParser.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRuleParser.java Thu May 12 18:03:26 2011
@@ -16,10 +16,8 @@
* limitations under the License.
*/
-
package org.apache.commons.digester3.xmlrules;
-
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URL;
@@ -53,820 +51,930 @@ import org.w3c.dom.Node;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
-
/**
- * This is a RuleSet that parses XML into Digester rules, and then
- * adds those rules to a 'target' Digester.
- *
+ * This is a RuleSet that parses XML into Digester rules, and then adds those rules to a 'target' Digester.
+ *
* @since 1.2
*/
-public class DigesterRuleParser extends RuleSetBase {
-
+public class DigesterRuleParser
+ extends RuleSetBase
+{
+
public static final String DIGESTER_PUBLIC_ID = "-//Jakarta Apache //DTD digester-rules XML V1.0//EN";
-
+
/**
* path to the DTD
*/
private String digesterDtdUrl;
-
+
/**
- * This is the digester to which we are adding the rules that we parse
- * from the Rules XML document.
+ * This is the digester to which we are adding the rules that we parse from the Rules XML document.
*/
protected Digester targetDigester;
/** See {@link #setBasePath}. */
protected String basePath = "";
-
+
/**
- * A stack whose toString method returns a '/'-separated concatenation
- * of all the elements in the stack.
+ * A stack whose toString method returns a '/'-separated concatenation of all the elements in the stack.
*/
- protected class PatternStack<E> extends Stack<E> {
+ protected class PatternStack<E>
+ extends Stack<E>
+ {
private static final long serialVersionUID = 1L;
@Override
- public String toString() {
+ public String toString()
+ {
StringBuilder str = new StringBuilder();
- for (int i = 0; i < size(); i++) {
- String elem = get(i).toString();
- if (elem.length() > 0) {
- if (str.length() > 0) {
- str.append('/');
+ for ( int i = 0; i < size(); i++ )
+ {
+ String elem = get( i ).toString();
+ if ( elem.length() > 0 )
+ {
+ if ( str.length() > 0 )
+ {
+ str.append( '/' );
}
- str.append(elem);
+ str.append( elem );
}
}
return str.toString();
}
}
-
+
/**
- * A stack used to maintain the current pattern. The Rules XML document
- * type allows nesting of patterns. If an element defines a matching
- * pattern, the resulting pattern is a concatenation of that pattern with
- * all the ancestor elements' patterns. Hence the need for a stack.
+ * A stack used to maintain the current pattern. The Rules XML document type allows nesting of patterns. If an
+ * element defines a matching pattern, the resulting pattern is a concatenation of that pattern with all the
+ * ancestor elements' patterns. Hence the need for a stack.
*/
protected PatternStack<String> patternStack;
-
+
/**
* Used to detect circular includes
*/
private Set<String> includedFiles = new HashSet<String>();
-
+
/**
- * Constructs a DigesterRuleParser. This object will be inoperable
- * until the target digester is set, via <code>setTarget(Digester)</code>
+ * Constructs a DigesterRuleParser. This object will be inoperable until the target digester is set, via
+ * <code>setTarget(Digester)</code>
*/
- public DigesterRuleParser() {
+ public DigesterRuleParser()
+ {
patternStack = new PatternStack<String>();
}
-
+
/**
- * 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 converting XML digester rule descriptions into Rule objects, and adding them to the
+ * given Digester
+ *
* @param targetDigester the Digester to add the rules to
*/
- public DigesterRuleParser(Digester targetDigester) {
+ public DigesterRuleParser( Digester targetDigester )
+ {
this.targetDigester = targetDigester;
patternStack = new PatternStack<String>();
}
-
+
/**
- * Constructs a rule set for parsing an XML digester rule file that
- * has been included within an outer XML digester rule file. In this
- * case, we must pass the pattern stack and the target digester
- * to the rule set, as well as the list of files that have already
- * been included, for cycle detection.
+ * Constructs a rule set for parsing an XML digester rule file that has been included within an outer XML digester
+ * rule file. In this case, we must pass the pattern stack and the target digester to the rule set, as well as the
+ * list of files that have already been included, for cycle detection.
+ *
* @param targetDigester the Digester to add the rules to
- * @param stack Stack containing the prefix pattern string to be prepended
- * to any pattern parsed by this rule set.
+ * @param stack Stack containing the prefix pattern string to be prepended to any pattern parsed by this rule set.
*/
- private DigesterRuleParser(Digester targetDigester,
- PatternStack<String> stack, Set<String> includedFiles) {
+ private DigesterRuleParser( Digester targetDigester, PatternStack<String> stack, Set<String> includedFiles )
+ {
this.targetDigester = targetDigester;
patternStack = stack;
this.includedFiles = includedFiles;
}
-
+
/**
* Sets the digester into which to add the parsed rules
+ *
* @param d the Digester to add the rules to
*/
- public void setTarget(Digester d) {
+ public void setTarget( Digester d )
+ {
targetDigester = d;
}
-
+
/**
- * Set a base pattern beneath which all the rules loaded by this
- * object will be registered. If this string is not empty, and does
- * not end in a "/", then one will be added.
- *
+ * Set a base pattern beneath which all the rules loaded by this object will be registered. If this string is not
+ * empty, and does not end in a "/", then one will be added.
+ *
* @since 1.6
*/
- public void setBasePath(String path) {
- if (path == null) {
+ public void setBasePath( String path )
+ {
+ if ( path == null )
+ {
basePath = "";
}
- else if ((path.length() > 0) && !path.endsWith("/")) {
+ else if ( ( path.length() > 0 ) && !path.endsWith( "/" ) )
+ {
basePath = path + "/";
- } else {
+ }
+ else
+ {
basePath = path;
}
}
/**
- * Sets the location of the digester rules DTD. This is the DTD used
- * to validate the rules XML file.
+ * Sets the location of the digester rules DTD. This is the DTD used to validate the rules XML file.
*/
- public void setDigesterRulesDTD(String dtdURL) {
+ public void setDigesterRulesDTD( String dtdURL )
+ {
digesterDtdUrl = dtdURL;
}
-
+
/**
- * Returns the location of the DTD used to validate the digester rules
- * XML document.
+ * Returns the location of the DTD used to validate the digester rules XML document.
*/
- protected String getDigesterRulesDTD() {
- //ClassLoader classLoader = getClass().getClassLoader();
- //URL url = classLoader.getResource(DIGESTER_DTD_PATH);
- //return url.toString();
+ protected String getDigesterRulesDTD()
+ {
+ // ClassLoader classLoader = getClass().getClassLoader();
+ // URL url = classLoader.getResource(DIGESTER_DTD_PATH);
+ // return url.toString();
return digesterDtdUrl;
}
-
+
/**
- * Adds a rule the the target digester. After a rule has been created by
- * parsing the XML, it is added to the digester by calling this method.
- * Typically, this method is called via reflection, when executing
- * a SetNextRule, from the Digester that is parsing the rules XML.
+ * Adds a rule the the target digester. After a rule has been created by parsing the XML, it is added to the
+ * digester by calling this method. Typically, this method is called via reflection, when executing a SetNextRule,
+ * from the Digester that is parsing the rules XML.
+ *
* @param rule a Rule to add to the target digester.
*/
- public void add(Rule rule) {
- targetDigester.addRule(
- basePath + patternStack.toString(), rule);
- }
-
-
- /**
- * Add to the given digester the set of Rule instances used to parse an XML
- * document defining Digester rules. When the digester parses an XML file,
- * it will add the resulting rules & patterns to the 'target digester'
- * that was passed in this RuleSet's constructor.<P>
- * If you extend this class to support additional rules, your implementation
- * should of this method should call this implementation first: i.e.
- * <code>super.addRuleInstances(digester);</code>
+ public void add( Rule rule )
+ {
+ targetDigester.addRule( basePath + patternStack.toString(), rule );
+ }
+
+ /**
+ * Add to the given digester the set of Rule instances used to parse an XML document defining Digester rules. When
+ * the digester parses an XML file, it will add the resulting rules & patterns to the 'target digester' that was
+ * passed in this RuleSet's constructor.
+ * <P>
+ * If you extend this class to support additional rules, your implementation should of this method should call this
+ * implementation first: i.e. <code>super.addRuleInstances(digester);</code>
*/
@Override
- public void addRuleInstances(Digester digester) {
+ public void addRuleInstances( Digester digester )
+ {
final String ruleClassName = Rule.class.getName();
- digester.register(DIGESTER_PUBLIC_ID, getDigesterRulesDTD());
-
- digester.addRule("*/pattern", new PatternRule("value"));
-
- digester.addRule("*/include", new IncludeRule());
-
- digester.addFactoryCreate("*/bean-property-setter-rule", new BeanPropertySetterRuleFactory());
- digester.addRule("*/bean-property-setter-rule", new PatternRule("pattern"));
- digester.addSetNext("*/bean-property-setter-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/call-method-rule", new CallMethodRuleFactory());
- digester.addRule("*/call-method-rule", new PatternRule("pattern"));
- digester.addSetNext("*/call-method-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/object-param-rule", new ObjectParamRuleFactory());
- digester.addRule("*/object-param-rule", new PatternRule("pattern"));
- digester.addSetNext("*/object-param-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/call-param-rule", new CallParamRuleFactory());
- digester.addRule("*/call-param-rule", new PatternRule("pattern"));
- digester.addSetNext("*/call-param-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/factory-create-rule", new FactoryCreateRuleFactory());
- digester.addRule("*/factory-create-rule", new PatternRule("pattern"));
- digester.addSetNext("*/factory-create-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/object-create-rule", new ObjectCreateRuleFactory());
- digester.addRule("*/object-create-rule", new PatternRule("pattern"));
- digester.addSetNext("*/object-create-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/node-create-rule", new NodeCreateRuleFactory());
- digester.addRule("*/node-create-rule", new PatternRule("pattern"));
- digester.addSetNext("*/node-create-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/set-properties-rule", new SetPropertiesRuleFactory());
- digester.addRule("*/set-properties-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-properties-rule", "add", ruleClassName);
-
- digester.addRule("*/set-properties-rule/alias", new SetPropertiesAliasRule());
-
- digester.addFactoryCreate("*/set-property-rule", new SetPropertyRuleFactory());
- digester.addRule("*/set-property-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-property-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory());
- digester.addRule("*/set-nested-properties-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-nested-properties-rule", "add", ruleClassName);
-
- digester.addRule("*/set-nested-properties-rule/alias", new SetNestedPropertiesAliasRule());
-
- digester.addFactoryCreate("*/set-top-rule", new SetTopRuleFactory());
- digester.addRule("*/set-top-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-top-rule", "add", ruleClassName);
-
- digester.addFactoryCreate("*/set-next-rule", new SetNextRuleFactory());
- digester.addRule("*/set-next-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-next-rule", "add", ruleClassName);
- digester.addFactoryCreate("*/set-root-rule", new SetRootRuleFactory());
- digester.addRule("*/set-root-rule", new PatternRule("pattern"));
- digester.addSetNext("*/set-root-rule", "add", ruleClassName);
- }
-
-
- /**
- * A rule for extracting the pattern matching strings from the rules XML.
- * In the digester-rules document type, a pattern can either be declared
- * in the 'value' attribute of a <pattern> element (in which case the pattern
- * applies to all rules elements contained within the <pattern> element),
- * or it can be declared in the optional 'pattern' attribute of a rule
- * element.
+ digester.register( DIGESTER_PUBLIC_ID, getDigesterRulesDTD() );
+
+ digester.addRule( "*/pattern", new PatternRule( "value" ) );
+
+ digester.addRule( "*/include", new IncludeRule() );
+
+ digester.addFactoryCreate( "*/bean-property-setter-rule", new BeanPropertySetterRuleFactory() );
+ digester.addRule( "*/bean-property-setter-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/bean-property-setter-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/call-method-rule", new CallMethodRuleFactory() );
+ digester.addRule( "*/call-method-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/call-method-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/object-param-rule", new ObjectParamRuleFactory() );
+ digester.addRule( "*/object-param-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/object-param-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/call-param-rule", new CallParamRuleFactory() );
+ digester.addRule( "*/call-param-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/call-param-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/factory-create-rule", new FactoryCreateRuleFactory() );
+ digester.addRule( "*/factory-create-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/factory-create-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/object-create-rule", new ObjectCreateRuleFactory() );
+ digester.addRule( "*/object-create-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/object-create-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/node-create-rule", new NodeCreateRuleFactory() );
+ digester.addRule( "*/node-create-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/node-create-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/set-properties-rule", new SetPropertiesRuleFactory() );
+ digester.addRule( "*/set-properties-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-properties-rule", "add", ruleClassName );
+
+ digester.addRule( "*/set-properties-rule/alias", new SetPropertiesAliasRule() );
+
+ digester.addFactoryCreate( "*/set-property-rule", new SetPropertyRuleFactory() );
+ digester.addRule( "*/set-property-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-property-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/set-nested-properties-rule", new SetNestedPropertiesRuleFactory() );
+ digester.addRule( "*/set-nested-properties-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-nested-properties-rule", "add", ruleClassName );
+
+ digester.addRule( "*/set-nested-properties-rule/alias", new SetNestedPropertiesAliasRule() );
+
+ digester.addFactoryCreate( "*/set-top-rule", new SetTopRuleFactory() );
+ digester.addRule( "*/set-top-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-top-rule", "add", ruleClassName );
+
+ digester.addFactoryCreate( "*/set-next-rule", new SetNextRuleFactory() );
+ digester.addRule( "*/set-next-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-next-rule", "add", ruleClassName );
+ digester.addFactoryCreate( "*/set-root-rule", new SetRootRuleFactory() );
+ digester.addRule( "*/set-root-rule", new PatternRule( "pattern" ) );
+ digester.addSetNext( "*/set-root-rule", "add", ruleClassName );
+ }
+
+ /**
+ * A rule for extracting the pattern matching strings from the rules XML. In the digester-rules document type, a
+ * pattern can either be declared in the 'value' attribute of a <pattern> element (in which case the pattern applies
+ * to all rules elements contained within the <pattern> element), or it can be declared in the optional 'pattern'
+ * attribute of a rule element.
*/
- private class PatternRule extends Rule {
-
+ private class PatternRule
+ extends Rule
+ {
+
private String attrName;
+
private String pattern = null;
-
+
/**
* @param attrName The name of the attribute containing the pattern
*/
- public PatternRule(String attrName) {
+ public PatternRule( String attrName )
+ {
super();
this.attrName = attrName;
}
-
+
/**
- * If a pattern is defined for the attribute, push it onto the
- * pattern stack.
+ * If a pattern is defined for the attribute, push it onto the pattern stack.
*/
@Override
- public void begin(String namespace, String name, Attributes attributes) throws Exception {
- pattern = attributes.getValue(attrName);
- if (pattern != null) {
- patternStack.push(pattern);
+ public void begin( String namespace, String name, Attributes attributes )
+ throws Exception
+ {
+ pattern = attributes.getValue( attrName );
+ if ( pattern != null )
+ {
+ patternStack.push( pattern );
}
}
-
+
/**
- * If there was a pattern for this element, pop it off the pattern
- * stack.
+ * If there was a pattern for this element, pop it off the pattern stack.
*/
@Override
- public void end(String namespace, String name) throws Exception {
- if (pattern != null) {
+ public void end( String namespace, String name )
+ throws Exception
+ {
+ if ( pattern != null )
+ {
patternStack.pop();
}
}
}
-
+
/**
- * A rule for including one rules XML file within another. Included files
- * behave as if they are 'macro-expanded' within the includer. This means
- * that the values of the pattern stack are prefixed to every pattern
- * in the included rules. <p>This rule will detect 'circular' includes,
- * which would result in infinite recursion. It throws a
- * CircularIncludeException when a cycle is detected, which will terminate
- * the parse.
- */
- private class IncludeRule extends Rule {
- public IncludeRule() {
+ * A rule for including one rules XML file within another. Included files behave as if they are 'macro-expanded'
+ * within the includer. This means that the values of the pattern stack are prefixed to every pattern in the
+ * included rules.
+ * <p>
+ * This rule will detect 'circular' includes, which would result in infinite recursion. It throws a
+ * CircularIncludeException when a cycle is detected, which will terminate the parse.
+ */
+ private class IncludeRule
+ extends Rule
+ {
+ public IncludeRule()
+ {
super();
}
-
+
/**
- * To include a rules xml file, we instantiate another Digester, and
- * another DigesterRulesRuleSet. We pass the
- * pattern stack and the target Digester to the new rule set, and
- * tell the Digester to parse the file.
+ * To include a rules xml file, we instantiate another Digester, and another DigesterRulesRuleSet. We pass the
+ * pattern stack and the target Digester to the new rule set, and tell the Digester to parse the file.
*/
@Override
- public void begin(String namespace, String name, Attributes attributes) throws Exception {
+ public void begin( String namespace, String name, Attributes attributes )
+ throws Exception
+ {
// The path attribute gives the URI to another digester rules xml file
- String fileName = attributes.getValue("path");
- if (fileName != null && fileName.length() > 0) {
- includeXMLRules(fileName);
+ String fileName = attributes.getValue( "path" );
+ if ( fileName != null && fileName.length() > 0 )
+ {
+ includeXMLRules( fileName );
}
-
+
// The class attribute gives the name of a class that implements
// the DigesterRulesSource interface
- String className = attributes.getValue("class");
- if (className != null && className.length() > 0) {
- includeProgrammaticRules(className);
+ String className = attributes.getValue( "class" );
+ if ( className != null && className.length() > 0 )
+ {
+ includeProgrammaticRules( className );
}
}
-
+
/**
- * Creates another DigesterRuleParser, and uses it to extract the rules
- * out of the give XML file. The contents of the current pattern stack
- * will be prepended to all of the pattern strings parsed from the file.
+ * Creates another DigesterRuleParser, and uses it to extract the rules out of the give XML file. The contents
+ * of the current pattern stack will be prepended to all of the pattern strings parsed from the file.
*/
- private void includeXMLRules(String fileName)
- throws IOException, SAXException, CircularIncludeException {
+ private void includeXMLRules( String fileName )
+ throws IOException, SAXException, CircularIncludeException
+ {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
- if (cl == null) {
+ if ( cl == null )
+ {
cl = DigesterRuleParser.this.getClass().getClassLoader();
}
- URL fileURL = cl.getResource(fileName);
- if (fileURL == null) {
- throw new FileNotFoundException("File \"" + fileName + "\" not found.");
+ URL fileURL = cl.getResource( fileName );
+ if ( fileURL == null )
+ {
+ throw new FileNotFoundException( "File \"" + fileName + "\" not found." );
}
fileName = fileURL.toExternalForm();
- if (includedFiles.add(fileName) == false) {
+ if ( includedFiles.add( fileName ) == false )
+ {
// circular include detected
- throw new CircularIncludeException(fileName);
+ throw new CircularIncludeException( fileName );
}
// parse the included xml file
- DigesterRuleParser includedSet =
- new DigesterRuleParser(targetDigester, patternStack, includedFiles);
- includedSet.setDigesterRulesDTD(getDigesterRulesDTD());
+ DigesterRuleParser includedSet = new DigesterRuleParser( targetDigester, patternStack, includedFiles );
+ includedSet.setDigesterRulesDTD( getDigesterRulesDTD() );
Digester digester = new Digester();
- digester.addRuleSet(includedSet);
- digester.push(DigesterRuleParser.this);
- digester.parse(fileName);
- includedFiles.remove(fileName);
- }
-
- /**
- * Creates an instance of the indicated class. The class must implement
- * the DigesterRulesSource interface. Passes the target digester to
- * that instance. The DigesterRulesSource instance is supposed to add
- * rules into the digester. The contents of the current pattern stack
- * will be automatically prepended to all of the pattern strings added
- * by the DigesterRulesSource instance.
- */
- private void includeProgrammaticRules(String className)
- throws ClassNotFoundException, ClassCastException,
- InstantiationException, IllegalAccessException {
-
- Class<?> cls = Class.forName(className);
+ digester.addRuleSet( includedSet );
+ digester.push( DigesterRuleParser.this );
+ digester.parse( fileName );
+ includedFiles.remove( fileName );
+ }
+
+ /**
+ * Creates an instance of the indicated class. The class must implement the DigesterRulesSource interface.
+ * Passes the target digester to that instance. The DigesterRulesSource instance is supposed to add rules into
+ * the digester. The contents of the current pattern stack will be automatically prepended to all of the pattern
+ * strings added by the DigesterRulesSource instance.
+ */
+ private void includeProgrammaticRules( String className )
+ throws ClassNotFoundException, ClassCastException, InstantiationException, IllegalAccessException
+ {
+
+ Class<?> cls = Class.forName( className );
DigesterRulesSource rulesSource = (DigesterRulesSource) cls.newInstance();
-
+
// wrap the digester's Rules object, to prepend pattern
Rules digesterRules = targetDigester.getRules();
- Rules prefixWrapper =
- new RulesPrefixAdapter(patternStack.toString(), digesterRules);
-
- targetDigester.setRules(prefixWrapper);
- try {
- rulesSource.getRules(targetDigester);
- } finally {
+ Rules prefixWrapper = new RulesPrefixAdapter( patternStack.toString(), digesterRules );
+
+ targetDigester.setRules( prefixWrapper );
+ try
+ {
+ rulesSource.getRules( targetDigester );
+ }
+ finally
+ {
// Put the unwrapped rules back
- targetDigester.setRules(digesterRules);
+ targetDigester.setRules( digesterRules );
}
}
}
-
-
+
/**
- * Wraps a Rules object. Delegates all the Rules interface methods
- * to the underlying Rules object. Overrides the add method to prepend
- * a prefix to the pattern string.
+ * Wraps a Rules object. Delegates all the Rules interface methods to the underlying Rules object. Overrides the add
+ * method to prepend a prefix to the pattern string.
*/
- private class RulesPrefixAdapter implements Rules {
-
+ private class RulesPrefixAdapter
+ implements Rules
+ {
+
private Rules delegate;
+
private String prefix;
-
+
/**
- * @param patternPrefix the pattern string to prepend to the pattern
- * passed to the add method.
- * @param rules The wrapped Rules object. All of this class's methods
- * pass through to this object.
+ * @param patternPrefix the pattern string to prepend to the pattern passed to the add method.
+ * @param rules The wrapped Rules object. All of this class's methods pass through to this object.
*/
- public RulesPrefixAdapter(String patternPrefix, Rules rules) {
+ public RulesPrefixAdapter( String patternPrefix, Rules rules )
+ {
prefix = patternPrefix;
delegate = rules;
}
-
+
/**
- * 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 a pattern which is constructed by concatenating the pattern prefix with
+ * the given pattern.
*/
- public void add(String pattern, Rule rule) {
+ public void add( String pattern, Rule rule )
+ {
StringBuilder buffer = new StringBuilder();
- buffer.append(prefix);
- if (!pattern.startsWith("/")) {
- buffer.append('/');
+ buffer.append( prefix );
+ if ( !pattern.startsWith( "/" ) )
+ {
+ buffer.append( '/' );
}
- buffer.append(pattern);
- delegate.add(buffer.toString(), rule);
+ buffer.append( pattern );
+ delegate.add( buffer.toString(), rule );
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public void clear() {
+ public void clear()
+ {
delegate.clear();
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public Digester getDigester() {
+ public Digester getDigester()
+ {
return delegate.getDigester();
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public String getNamespaceURI() {
+ public String getNamespaceURI()
+ {
return delegate.getNamespaceURI();
}
-
+
/**
* @deprecated Call match(namespaceURI,pattern) instead.
*/
@Deprecated
- public List<Rule> match(String pattern) {
- return delegate.match(pattern);
+ public List<Rule> match( String pattern )
+ {
+ return delegate.match( pattern );
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public List<Rule> match(String namespaceURI, String pattern) {
- return delegate.match(namespaceURI, pattern);
+ public List<Rule> match( String namespaceURI, String pattern )
+ {
+ return delegate.match( namespaceURI, pattern );
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public List<Rule> rules() {
+ public List<Rule> rules()
+ {
return delegate.rules();
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public void setDigester(Digester digester) {
- delegate.setDigester(digester);
+ public void setDigester( Digester digester )
+ {
+ delegate.setDigester( digester );
}
-
+
/**
* This method passes through to the underlying Rules object.
*/
- public void setNamespaceURI(String namespaceURI) {
- delegate.setNamespaceURI(namespaceURI);
+ public void setNamespaceURI( String namespaceURI )
+ {
+ delegate.setNamespaceURI( namespaceURI );
}
}
-
-
- ///////////////////////////////////////////////////////////////////////
+
+ // /////////////////////////////////////////////////////////////////////
// Classes beyond this point are ObjectCreationFactory implementations,
// used to create Rule objects and initialize them from SAX attributes.
- ///////////////////////////////////////////////////////////////////////
-
+ // /////////////////////////////////////////////////////////////////////
+
/**
* Factory for creating a BeanPropertySetterRule.
*/
- private class BeanPropertySetterRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) throws Exception {
+ private class BeanPropertySetterRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ throws Exception
+ {
Rule beanPropertySetterRule = null;
- String propertyname = attributes.getValue("propertyname");
-
- if (propertyname == null) {
+ String propertyname = attributes.getValue( "propertyname" );
+
+ if ( propertyname == null )
+ {
// call the setter method corresponding to the element name.
beanPropertySetterRule = new BeanPropertySetterRule();
- } else {
- beanPropertySetterRule = new BeanPropertySetterRule(propertyname);
}
-
+ else
+ {
+ beanPropertySetterRule = new BeanPropertySetterRule( propertyname );
+ }
+
return beanPropertySetterRule;
}
-
+
}
/**
* Factory for creating a CallMethodRule.
*/
- protected class CallMethodRuleFactory extends AbstractObjectCreationFactory {
+ protected class CallMethodRuleFactory
+ extends AbstractObjectCreationFactory
+ {
@Override
- public Object createObject(Attributes attributes) {
+ public Object createObject( Attributes attributes )
+ {
Rule callMethodRule = null;
- String methodName = attributes.getValue("methodname");
+ String methodName = attributes.getValue( "methodname" );
// Select which element is to be the target. Default to zero,
// ie the top object on the stack.
int targetOffset = 0;
- String targetOffsetStr = attributes.getValue("targetoffset");
- if (targetOffsetStr != null) {
- targetOffset = Integer.parseInt(targetOffsetStr);
+ String targetOffsetStr = attributes.getValue( "targetoffset" );
+ if ( targetOffsetStr != null )
+ {
+ targetOffset = Integer.parseInt( targetOffsetStr );
}
- if (attributes.getValue("paramcount") == null) {
+ if ( attributes.getValue( "paramcount" ) == null )
+ {
// call against empty method
- callMethodRule = new CallMethodRule(targetOffset, methodName);
-
- } else {
- int paramCount = Integer.parseInt(attributes.getValue("paramcount"));
-
- String paramTypesAttr = attributes.getValue("paramtypes");
- if (paramTypesAttr == null || paramTypesAttr.length() == 0) {
- callMethodRule = new CallMethodRule(targetOffset, methodName, paramCount);
- } else {
- String[] paramTypes = getParamTypes(paramTypesAttr);
- callMethodRule = new CallMethodRule(
- targetOffset, methodName, paramCount, paramTypes);
+ callMethodRule = new CallMethodRule( targetOffset, methodName );
+
+ }
+ else
+ {
+ int paramCount = Integer.parseInt( attributes.getValue( "paramcount" ) );
+
+ String paramTypesAttr = attributes.getValue( "paramtypes" );
+ if ( paramTypesAttr == null || paramTypesAttr.length() == 0 )
+ {
+ callMethodRule = new CallMethodRule( targetOffset, methodName, paramCount );
+ }
+ else
+ {
+ String[] paramTypes = getParamTypes( paramTypesAttr );
+ callMethodRule = new CallMethodRule( targetOffset, methodName, paramCount, paramTypes );
}
}
return callMethodRule;
}
/**
- * Process the comma separated list of paramTypes
- * into an array of String class names
+ * Process the comma separated list of paramTypes into an array of String class names
*/
- private String[] getParamTypes(String paramTypes) {
+ private String[] getParamTypes( String paramTypes )
+ {
String[] paramTypesArray;
- if( paramTypes != null ) {
+ if ( paramTypes != null )
+ {
ArrayList<String> paramTypesList = new ArrayList<String>();
- StringTokenizer tokens = new StringTokenizer(
- paramTypes, " \t\n\r,");
- while (tokens.hasMoreTokens()) {
- paramTypesList.add(tokens.nextToken());
+ StringTokenizer tokens = new StringTokenizer( paramTypes, " \t\n\r," );
+ while ( tokens.hasMoreTokens() )
+ {
+ paramTypesList.add( tokens.nextToken() );
}
- paramTypesArray = paramTypesList.toArray(new String[0]);
- } else {
+ paramTypesArray = paramTypesList.toArray( new String[0] );
+ }
+ else
+ {
paramTypesArray = new String[0];
}
return paramTypesArray;
}
}
-
+
/**
* Factory for creating a CallParamRule.
*/
- protected class CallParamRuleFactory extends AbstractObjectCreationFactory {
-
+ protected class CallParamRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+
@Override
- public Object createObject(Attributes attributes) {
+ public Object createObject( Attributes attributes )
+ {
// create callparamrule
- int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
- String attributeName = attributes.getValue("attrname");
- String fromStack = attributes.getValue("from-stack");
- String stackIndex = attributes.getValue("stack-index");
+ int paramIndex = Integer.parseInt( attributes.getValue( "paramnumber" ) );
+ String attributeName = attributes.getValue( "attrname" );
+ String fromStack = attributes.getValue( "from-stack" );
+ String stackIndex = attributes.getValue( "stack-index" );
Rule callParamRule = null;
- if (attributeName == null) {
- if (stackIndex != null) {
- callParamRule = new CallParamRule(
- paramIndex, Integer.parseInt(stackIndex));
- } else if (fromStack != null) {
- callParamRule = new CallParamRule(
- paramIndex, Boolean.valueOf(fromStack).booleanValue());
- } else {
- callParamRule = new CallParamRule(paramIndex);
+ if ( attributeName == null )
+ {
+ if ( stackIndex != null )
+ {
+ callParamRule = new CallParamRule( paramIndex, Integer.parseInt( stackIndex ) );
+ }
+ else if ( fromStack != null )
+ {
+ callParamRule = new CallParamRule( paramIndex, Boolean.valueOf( fromStack ).booleanValue() );
+ }
+ else
+ {
+ callParamRule = new CallParamRule( paramIndex );
}
- } else {
- if (fromStack == null) {
- callParamRule = new CallParamRule(paramIndex, attributeName);
- } else {
+ }
+ else
+ {
+ if ( fromStack == null )
+ {
+ callParamRule = new CallParamRule( paramIndex, attributeName );
+ }
+ else
+ {
// specifying both from-stack and attribute name is not allowed
- throw new RuntimeException(
- "Attributes from-stack and attrname cannot both be present.");
+ throw new RuntimeException( "Attributes from-stack and attrname cannot both be present." );
}
}
return callParamRule;
}
}
-
+
/**
* Factory for creating a ObjectParamRule
*/
- protected class ObjectParamRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) throws Exception {
+ protected class ObjectParamRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ throws Exception
+ {
// create callparamrule
- int paramIndex = Integer.parseInt(attributes.getValue("paramnumber"));
- String attributeName = attributes.getValue("attrname");
- String type = attributes.getValue("type");
- String value = attributes.getValue("value");
+ int paramIndex = Integer.parseInt( attributes.getValue( "paramnumber" ) );
+ String attributeName = attributes.getValue( "attrname" );
+ String type = attributes.getValue( "type" );
+ String value = attributes.getValue( "value" );
Rule objectParamRule = null;
// type name is requried
- if (type == null) {
- throw new RuntimeException("Attribute 'type' is required.");
+ if ( type == null )
+ {
+ throw new RuntimeException( "Attribute 'type' is required." );
}
// create object instance
Object param = null;
- Class<?> clazz = Class.forName(type);
- if (value == null) {
+ Class<?> clazz = Class.forName( type );
+ if ( value == null )
+ {
param = clazz.newInstance();
- } else {
- param = ConvertUtils.convert(value, clazz);
+ }
+ else
+ {
+ param = ConvertUtils.convert( value, clazz );
}
- if (attributeName == null) {
- objectParamRule = new ObjectParamRule(paramIndex, param);
- } else {
- objectParamRule = new ObjectParamRule(paramIndex, attributeName, param);
+ if ( attributeName == null )
+ {
+ objectParamRule = new ObjectParamRule( paramIndex, param );
+ }
+ else
+ {
+ objectParamRule = new ObjectParamRule( paramIndex, attributeName, param );
}
return objectParamRule;
}
- }
-
- /**
- * Factory for creating a NodeCreateRule
- */
- protected class NodeCreateRuleFactory extends AbstractObjectCreationFactory {
+ }
+
+ /**
+ * Factory for creating a NodeCreateRule
+ */
+ protected class NodeCreateRuleFactory
+ extends AbstractObjectCreationFactory
+ {
@Override
- public Object createObject(Attributes attributes) throws Exception {
+ public Object createObject( Attributes attributes )
+ throws Exception
+ {
- String nodeType = attributes.getValue("type");
- if (nodeType == null || "".equals(nodeType)) {
+ String nodeType = attributes.getValue( "type" );
+ if ( nodeType == null || "".equals( nodeType ) )
+ {
// uses Node.ELEMENT_NODE
return new NodeCreateRule();
- } else if ("element".equals(nodeType)) {
+ }
+ else if ( "element".equals( nodeType ) )
+ {
- return new NodeCreateRule(Node.ELEMENT_NODE);
- } else if ("fragment".equals(nodeType)) {
+ return new NodeCreateRule( Node.ELEMENT_NODE );
+ }
+ else if ( "fragment".equals( nodeType ) )
+ {
- return new NodeCreateRule(Node.DOCUMENT_FRAGMENT_NODE);
- } else {
+ return new NodeCreateRule( Node.DOCUMENT_FRAGMENT_NODE );
+ }
+ else
+ {
- throw new RuntimeException(
- "Unrecognized node type: "
- + nodeType
- + ". This attribute is optional or can have a value of element|fragment.");
+ throw new RuntimeException( "Unrecognized node type: " + nodeType
+ + ". This attribute is optional or can have a value of element|fragment." );
}
}
- }
-
+ }
+
/**
* Factory for creating a FactoryCreateRule
*/
- protected class FactoryCreateRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- String className = attributes.getValue("classname");
- String attrName = attributes.getValue("attrname");
- boolean ignoreExceptions =
- "true".equalsIgnoreCase(attributes.getValue("ignore-exceptions"));
- return (attrName == null || attrName.length() == 0) ?
- new FactoryCreateRule( className, ignoreExceptions) :
- new FactoryCreateRule( className, attrName, ignoreExceptions);
+ protected class FactoryCreateRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ String className = attributes.getValue( "classname" );
+ String attrName = attributes.getValue( "attrname" );
+ boolean ignoreExceptions = "true".equalsIgnoreCase( attributes.getValue( "ignore-exceptions" ) );
+ return ( attrName == null || attrName.length() == 0 ) ? new FactoryCreateRule( className, ignoreExceptions )
+ : new FactoryCreateRule( className, attrName, ignoreExceptions );
}
}
-
+
/**
* Factory for creating a ObjectCreateRule
*/
- protected class ObjectCreateRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- String className = attributes.getValue("classname");
- String attrName = attributes.getValue("attrname");
- return (attrName == null || attrName.length() == 0) ?
- new ObjectCreateRule( className) :
- new ObjectCreateRule( className, attrName);
+ protected class ObjectCreateRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ String className = attributes.getValue( "classname" );
+ String attrName = attributes.getValue( "attrname" );
+ return ( attrName == null || attrName.length() == 0 ) ? new ObjectCreateRule( className )
+ : new ObjectCreateRule( className, attrName );
}
}
-
+
/**
* Factory for creating a SetPropertiesRule
*/
- protected class SetPropertiesRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- return new SetPropertiesRule();
+ protected class SetPropertiesRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ return new SetPropertiesRule();
}
}
-
+
/**
* Factory for creating a SetPropertyRule
*/
- protected class SetPropertyRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- String name = attributes.getValue("name");
- String value = attributes.getValue("value");
- return new SetPropertyRule( name, value);
+ protected class SetPropertyRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ String name = attributes.getValue( "name" );
+ String value = attributes.getValue( "value" );
+ return new SetPropertyRule( name, value );
}
}
-
+
/**
* Factory for creating a SetNestedPropertiesRule
*/
- protected class SetNestedPropertiesRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- boolean allowUnknownChildElements =
- "true".equalsIgnoreCase(attributes.getValue("allow-unknown-child-elements"));
- SetNestedPropertiesRule snpr = new SetNestedPropertiesRule();
- snpr.setAllowUnknownChildElements( allowUnknownChildElements );
- return snpr;
+ protected class SetNestedPropertiesRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ boolean allowUnknownChildElements =
+ "true".equalsIgnoreCase( attributes.getValue( "allow-unknown-child-elements" ) );
+ SetNestedPropertiesRule snpr = new SetNestedPropertiesRule();
+ snpr.setAllowUnknownChildElements( allowUnknownChildElements );
+ return snpr;
}
}
-
+
/**
* Factory for creating a SetTopRuleFactory
*/
- protected class SetTopRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- String methodName = attributes.getValue("methodname");
- String paramType = attributes.getValue("paramtype");
- return (paramType == null || paramType.length() == 0) ?
- new SetTopRule( methodName) :
- new SetTopRule( methodName, paramType);
+ protected class SetTopRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ String methodName = attributes.getValue( "methodname" );
+ String paramType = attributes.getValue( "paramtype" );
+ return ( paramType == null || paramType.length() == 0 ) ? new SetTopRule( methodName )
+ : new SetTopRule( methodName, paramType );
}
}
-
+
/**
* Factory for creating a SetNextRuleFactory
*/
- protected class SetNextRuleFactory extends AbstractObjectCreationFactory {
- @Override
- public Object createObject(Attributes attributes) {
- String methodName = attributes.getValue("methodname");
- String paramType = attributes.getValue("paramtype");
- return (paramType == null || paramType.length() == 0) ?
- new SetNextRule( methodName) :
- new SetNextRule( methodName, paramType);
+ protected class SetNextRuleFactory
+ extends AbstractObjectCreationFactory
+ {
+ @Override
+ public Object createObject( Attributes attributes )
+ {
+ String methodName = attributes.getValue( "methodname" );
+ String paramType = attributes.getValue( "paramtype" );
+ return ( paramType == null || paramType.length() == 0 ) ? new SetNextRule( methodName )
+ : new SetNextRule( methodName, paramType );
}
}
-
+
/**
* Factory for creating a SetRootRuleFactory
*/
- protected class SetRootRuleFactory extends AbstractObjectCreationFactory {
+ protected class SetRootRuleFactory
+ extends AbstractObjectCreationFactory
+ {
@Override
- public Object createObject(Attributes attributes) {
- String methodName = attributes.getValue("methodname");
- String paramType = attributes.getValue("paramtype");
- return (paramType == null || paramType.length() == 0) ?
- new SetRootRule( methodName) :
- new SetRootRule( methodName, paramType);
+ public Object createObject( Attributes attributes )
+ {
+ String methodName = attributes.getValue( "methodname" );
+ String paramType = attributes.getValue( "paramtype" );
+ return ( paramType == null || paramType.length() == 0 ) ? new SetRootRule( methodName )
+ : new SetRootRule( methodName, paramType );
}
}
-
+
/**
- * A rule for adding a attribute-property alias to the custom alias mappings of
- * the containing SetPropertiesRule rule.
+ * A rule for adding a attribute-property alias to the custom alias mappings of the containing SetPropertiesRule
+ * rule.
*/
- protected class SetPropertiesAliasRule extends Rule {
-
+ protected class SetPropertiesAliasRule
+ extends Rule
+ {
+
/**
- * <p>Base constructor.</p>
+ * <p>
+ * Base constructor.
+ * </p>
*/
- public SetPropertiesAliasRule() {
+ public SetPropertiesAliasRule()
+ {
super();
}
-
+
/**
- * Add the alias to the SetPropertiesRule object created by the
- * enclosing <set-properties-rule> tag.
+ * Add the alias to the SetPropertiesRule object created by the enclosing <set-properties-rule> tag.
*/
@Override
- public void begin(String namespace, String name, Attributes attributes) throws Exception {
- String attrName = attributes.getValue("attr-name");
- String propName = attributes.getValue("prop-name");
-
+ public void begin( String namespace, String name, Attributes attributes )
+ throws Exception
+ {
+ String attrName = attributes.getValue( "attr-name" );
+ String propName = attributes.getValue( "prop-name" );
+
SetPropertiesRule rule = (SetPropertiesRule) getDigester().peek();
- rule.addAlias(attrName, propName);
+ rule.addAlias( attrName, propName );
}
}
/**
- * A rule for adding a attribute-property alias to the custom alias mappings of
- * the containing SetNestedPropertiesRule rule.
+ * A rule for adding a attribute-property alias to the custom alias mappings of the containing
+ * SetNestedPropertiesRule rule.
*/
- protected class SetNestedPropertiesAliasRule extends Rule {
-
+ protected class SetNestedPropertiesAliasRule
+ extends Rule
+ {
+
/**
- * <p>Base constructor.</p>
+ * <p>
+ * Base constructor.
+ * </p>
*/
- public SetNestedPropertiesAliasRule() {
+ public SetNestedPropertiesAliasRule()
+ {
super();
}
-
+
/**
- * Add the alias to the SetNestedPropertiesRule object created by the
- * enclosing <set-nested-properties-rule> tag.
+ * Add the alias to the SetNestedPropertiesRule object created by the enclosing <set-nested-properties-rule>
+ * tag.
*/
@Override
- public void begin(String namespace, String name, Attributes attributes) throws Exception {
- String attrName = attributes.getValue("attr-name");
- String propName = attributes.getValue("prop-name");
-
+ public void begin( String namespace, String name, Attributes attributes )
+ throws Exception
+ {
+ String attrName = attributes.getValue( "attr-name" );
+ String propName = attributes.getValue( "prop-name" );
+
SetNestedPropertiesRule rule = (SetNestedPropertiesRule) getDigester().peek();
- rule.addAlias(attrName, propName);
+ rule.addAlias( attrName, propName );
}
}
-
+
}
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRulesSource.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRulesSource.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRulesSource.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/DigesterRulesSource.java Thu May 12 18:03:26 2011
@@ -16,27 +16,24 @@
* limitations under the License.
*/
-
package org.apache.commons.digester3.xmlrules;
-
import org.apache.commons.digester3.Digester;
-
/**
- * Interface for classes that initialize a Digester Rules object with
- * Digester Rules.
- *
+ * Interface for classes that initialize a Digester Rules object with Digester Rules.
+ *
* @since 1.2
*/
-public interface DigesterRulesSource {
+public interface DigesterRulesSource
+{
/**
* Creates and adds Digester Rules to a given Rules object
+ *
* @param digester the Digester to add the new Rule objects to
*/
- void getRules(Digester digester);
+ void getRules( Digester digester );
}
-
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/FromXmlRuleSet.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/FromXmlRuleSet.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/FromXmlRuleSet.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/FromXmlRuleSet.java Thu May 12 18:03:26 2011
@@ -16,10 +16,8 @@
* limitations under the License.
*/
-
package org.apache.commons.digester3.xmlrules;
-
import java.net.URL;
import org.apache.commons.digester3.Digester;
@@ -29,10 +27,12 @@ import org.xml.sax.InputSource;
/**
* A Digester rule set where the rules come from an XML file.
- *
+ *
* @since 1.2
*/
-public class FromXmlRuleSet extends RuleSetBase {
+public class FromXmlRuleSet
+ extends RuleSetBase
+{
public static final String DIGESTER_DTD_PATH = "org/apache/commons/digester3/xmlrules/digester-rules.dtd";
@@ -47,35 +47,38 @@ public class FromXmlRuleSet extends Rule
private DigesterRuleParser parser;
/**
- * The digester for loading the rules xml.
- */
+ * The digester for loading the rules xml.
+ */
private Digester rulesDigester;
/**
- * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
- * rulesDigester.
+ * Constructs a FromXmlRuleSet using the default DigesterRuleParser and rulesDigester.
+ *
* @param rulesXml the path to the XML document defining the Digester rules
*/
- public FromXmlRuleSet(URL rulesXml) {
- this(rulesXml, new DigesterRuleParser(), new Digester());
+ public FromXmlRuleSet( URL rulesXml )
+ {
+ this( rulesXml, new DigesterRuleParser(), new Digester() );
}
/**
- * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
- * a ruleDigester for loading the rules xml.
+ * Constructs a FromXmlRuleSet using the default DigesterRuleParser and a ruleDigester for loading the rules xml.
+ *
* @param rulesXml the path to the XML document defining the Digester rules
* @param rulesDigester the digester to read the rules xml.
*/
- public FromXmlRuleSet(URL rulesXml, Digester rulesDigester) {
- this(rulesXml, new DigesterRuleParser(), rulesDigester);
+ public FromXmlRuleSet( URL rulesXml, Digester rulesDigester )
+ {
+ this( rulesXml, new DigesterRuleParser(), rulesDigester );
}
/**
* @param rulesXml the path to the XML document defining the Digester rules
* @param parser an instance of DigesterRuleParser, for parsing the rules from XML
*/
- public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser) {
- this(rulesXml, parser, new Digester());
+ public FromXmlRuleSet( URL rulesXml, DigesterRuleParser parser )
+ {
+ this( rulesXml, parser, new Digester() );
}
/**
@@ -83,35 +86,39 @@ public class FromXmlRuleSet extends Rule
* @param parser an instance of DigesterRuleParser, for parsing the rules from XML
* @param rulesDigester the digester used to load the Xml rules.
*/
- public FromXmlRuleSet(URL rulesXml, DigesterRuleParser parser, Digester rulesDigester) {
- init(new URLXMLRulesLoader(rulesXml), parser, rulesDigester);
+ public FromXmlRuleSet( URL rulesXml, DigesterRuleParser parser, Digester rulesDigester )
+ {
+ init( new URLXMLRulesLoader( rulesXml ), parser, rulesDigester );
}
/**
- * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
- * rulesDigester.
+ * Constructs a FromXmlRuleSet using the default DigesterRuleParser and rulesDigester.
+ *
* @param inputSource load the xml rules from this InputSource
*/
- public FromXmlRuleSet(InputSource inputSource) {
- this(inputSource, new DigesterRuleParser(), new Digester());
+ public FromXmlRuleSet( InputSource inputSource )
+ {
+ this( inputSource, new DigesterRuleParser(), new Digester() );
}
-
+
/**
- * Constructs a FromXmlRuleSet using the default DigesterRuleParser and
- * a ruleDigester for loading the rules xml.
+ * Constructs a FromXmlRuleSet using the default DigesterRuleParser and a ruleDigester for loading the rules xml.
+ *
* @param inputSource load the xml rules from this InputSource
* @param rulesDigester the digester to read the rules xml.
*/
- public FromXmlRuleSet(InputSource inputSource, Digester rulesDigester) {
- this(inputSource, new DigesterRuleParser(), rulesDigester);
+ public FromXmlRuleSet( InputSource inputSource, Digester rulesDigester )
+ {
+ this( inputSource, new DigesterRuleParser(), rulesDigester );
}
/**
* @param inputSource load the xml rules from this InputSource
* @param parser an instance of DigesterRuleParser, for parsing the rules from XML
*/
- public FromXmlRuleSet(InputSource inputSource, DigesterRuleParser parser) {
- this(inputSource, parser, new Digester());
+ public FromXmlRuleSet( InputSource inputSource, DigesterRuleParser parser )
+ {
+ this( inputSource, parser, new Digester() );
}
/**
@@ -119,105 +126,122 @@ public class FromXmlRuleSet extends Rule
* @param parser an instance of DigesterRuleParser, for parsing the rules from XML
* @param rulesDigester the digester used to load the Xml rules.
*/
- public FromXmlRuleSet(InputSource inputSource, DigesterRuleParser parser, Digester rulesDigester) {
- init(new InputSourceXMLRulesLoader(inputSource), parser, rulesDigester);
+ public FromXmlRuleSet( InputSource inputSource, DigesterRuleParser parser, Digester rulesDigester )
+ {
+ init( new InputSourceXMLRulesLoader( inputSource ), parser, rulesDigester );
}
-
+
/**
* Base constructor
*/
- private void init(XMLRulesLoader rulesLoader, DigesterRuleParser parser, Digester rulesDigester) {
+ private void init( XMLRulesLoader rulesLoader, DigesterRuleParser parser, Digester rulesDigester )
+ {
this.rulesLoader = rulesLoader;
this.parser = parser;
this.rulesDigester = rulesDigester;
}
-
+
/**
- * Adds to the digester the set of Rule instances defined in the
- * XML file for this rule set.
+ * Adds to the digester the set of Rule instances defined in the XML file for this rule set.
+ *
* @see org.apache.commons.digester3.RuleSetBase
*/
@Override
- public void addRuleInstances(org.apache.commons.digester3.Digester digester) throws XmlLoadException {
- addRuleInstances(digester, null);
+ public void addRuleInstances( org.apache.commons.digester3.Digester digester )
+ throws XmlLoadException
+ {
+ addRuleInstances( digester, null );
}
-
+
/**
- * Adds to the digester the set of Rule instances defined in the
- * XML file for this rule set.
+ * Adds to the digester the set of Rule instances defined in the XML file for this rule set.
* <p>
- * Note that this method doesn't have a matching one on the DigesterLoader
- * class, because it is not expected to be widely used, and DigesterLoader's
- * load method is already heavily overloaded.
- *
+ * Note that this method doesn't have a matching one on the DigesterLoader class, because it is not expected to be
+ * widely used, and DigesterLoader's load method is already heavily overloaded.
+ *
* @param digester is the digester that rules will be added to.
- * @param basePath is a path that will be prefixed to every
- * pattern string defined in the xmlrules input file.
- *
+ * @param basePath is a path that will be prefixed to every pattern string defined in the xmlrules input file.
* @see org.apache.commons.digester3.RuleSetBase
* @since 1.6
*/
- public void addRuleInstances(
- org.apache.commons.digester3.Digester digester,
- String basePath)
- throws XmlLoadException {
-
- URL dtdURL = getClass().getClassLoader().getResource(DIGESTER_DTD_PATH);
- if (dtdURL == null) {
- throw new XmlLoadException("Cannot find resource \"" +
- DIGESTER_DTD_PATH + "\"");
+ public void addRuleInstances( org.apache.commons.digester3.Digester digester, String basePath )
+ throws XmlLoadException
+ {
+
+ URL dtdURL = getClass().getClassLoader().getResource( DIGESTER_DTD_PATH );
+ if ( dtdURL == null )
+ {
+ throw new XmlLoadException( "Cannot find resource \"" + DIGESTER_DTD_PATH + "\"" );
}
- parser.setDigesterRulesDTD(dtdURL.toString());
- parser.setTarget(digester);
- parser.setBasePath(basePath);
+ parser.setDigesterRulesDTD( dtdURL.toString() );
+ parser.setTarget( digester );
+ parser.setBasePath( basePath );
- rulesDigester.addRuleSet(parser);
- rulesDigester.push(parser);
+ rulesDigester.addRuleSet( parser );
+ rulesDigester.push( parser );
rulesLoader.loadRules();
}
-
- /**
- * Worker class encapsulates loading mechanisms.
- * Private until some reason is found to make it public.
+
+ /**
+ * Worker class encapsulates loading mechanisms. Private until some reason is found to make it public.
*/
- private abstract static class XMLRulesLoader {
+ private abstract static class XMLRulesLoader
+ {
/** Load rules now */
- public abstract void loadRules() throws XmlLoadException;
+ public abstract void loadRules()
+ throws XmlLoadException;
}
-
+
/** Loads XMLRules from an URL */
- private class URLXMLRulesLoader extends XMLRulesLoader {
+ private class URLXMLRulesLoader
+ extends XMLRulesLoader
+ {
private URL url;
- public URLXMLRulesLoader(URL url) {
+
+ public URLXMLRulesLoader( URL url )
+ {
this.url = url;
}
-
+
@Override
- public void loadRules() throws XmlLoadException {
- try {
- rulesDigester.parse(url.openStream());
- } catch (Exception ex) {
- throw new XmlLoadException(ex);
+ public void loadRules()
+ throws XmlLoadException
+ {
+ try
+ {
+ rulesDigester.parse( url.openStream() );
+ }
+ catch ( Exception ex )
+ {
+ throw new XmlLoadException( ex );
}
}
}
/** Loads XMLRules from an InputSource */
- private class InputSourceXMLRulesLoader extends XMLRulesLoader {
+ private class InputSourceXMLRulesLoader
+ extends XMLRulesLoader
+ {
private InputSource inputSource;
- public InputSourceXMLRulesLoader(InputSource inputSource) {
+
+ public InputSourceXMLRulesLoader( InputSource inputSource )
+ {
this.inputSource = inputSource;
}
-
+
@Override
- public void loadRules() throws XmlLoadException {
- try {
- rulesDigester.parse(inputSource);
- } catch (Exception ex) {
- throw new XmlLoadException(ex);
+ public void loadRules()
+ throws XmlLoadException
+ {
+ try
+ {
+ rulesDigester.parse( inputSource );
+ }
+ catch ( Exception ex )
+ {
+ throw new XmlLoadException( ex );
}
}
}
}
-
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/XmlLoadException.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/XmlLoadException.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/XmlLoadException.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/XmlLoadException.java Thu May 12 18:03:26 2011
@@ -16,43 +16,47 @@
* limitations under the License.
*/
-
package org.apache.commons.digester3.xmlrules;
-
/**
* Thrown when an error occurs while parsing XML into Digester rules.
- *
+ *
* @since 1.2
*/
-public class XmlLoadException extends RuntimeException {
+public class XmlLoadException
+ extends RuntimeException
+{
private static final long serialVersionUID = 1L;
+
private Throwable cause = null;
/**
* @param cause underlying exception that caused this to be thrown
*/
- public XmlLoadException(Throwable cause) {
- this(cause.getMessage());
+ public XmlLoadException( Throwable cause )
+ {
+ this( cause.getMessage() );
this.cause = cause;
}
- public XmlLoadException(String msg) {
- super(msg);
+ public XmlLoadException( String msg )
+ {
+ super( msg );
}
- public XmlLoadException(String msg, Throwable cause) {
- this(msg);
+ public XmlLoadException( String msg, Throwable cause )
+ {
+ this( msg );
this.cause = cause;
}
-
- /**
- * Returns the cause of this throwable or null if the cause is
- * nonexistent or unknown.
+
+ /**
+ * Returns the cause of this throwable or null if the cause is nonexistent or unknown.
*/
@Override
- public Throwable getCause() {
+ public Throwable getCause()
+ {
return cause;
}
}
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/package-info.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/package-info.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/package-info.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/xmlrules/package-info.java Thu May 12 18:03:26 2011
@@ -22,3 +22,4 @@
* nested XML elements is recognized.
*/
package org.apache.commons.digester3.xmlrules;
+
Modified: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/Address.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/Address.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/Address.java (original)
+++ commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/Address.java Thu May 12 18:03:26 2011
@@ -18,93 +18,106 @@
package org.apache.commons.digester3;
-
/**
* Bean for Digester testing.
*/
+public class Address
+{
-public class Address {
-
- public Address() {
- this("My Street", "My City", "US", "MyZip");
+ public Address()
+ {
+ this( "My Street", "My City", "US", "MyZip" );
}
- public Address(String street, String city, String state, String zipCode) {
+ public Address( String street, String city, String state, String zipCode )
+ {
super();
- setStreet(street);
- setCity(city);
- setState(state);
- setZipCode(zipCode);
+ setStreet( street );
+ setCity( city );
+ setState( state );
+ setZipCode( zipCode );
}
private String city = null;
- public String getCity() {
- return (this.city);
+ public String getCity()
+ {
+ return ( this.city );
}
- public void setCity(String city) {
+ public void setCity( String city )
+ {
this.city = city;
}
private String state = null;
- public String getState() {
- return (this.state);
+ public String getState()
+ {
+ return ( this.state );
}
- public void setState(String state) {
+ public void setState( String state )
+ {
this.state = state;
}
private String street = null;
- public String getStreet() {
- return (this.street);
+ public String getStreet()
+ {
+ return ( this.street );
}
- public void setStreet(String street) {
+ public void setStreet( String street )
+ {
this.street = street;
}
private String type = null;
- public String getType() {
- return (this.type);
+ public String getType()
+ {
+ return ( this.type );
}
- public void setType(String type) {
+ public void setType( String type )
+ {
this.type = type;
}
private String zipCode = null;
- public String getZipCode() {
- return (this.zipCode);
+ public String getZipCode()
+ {
+ return ( this.zipCode );
}
- public void setZipCode(String zipCode) {
+ public void setZipCode( String zipCode )
+ {
this.zipCode = zipCode;
}
- public void setEmployee(Employee employee) {
- employee.addAddress(this);
+ public void setEmployee( Employee employee )
+ {
+ employee.addAddress( this );
}
@Override
- public String toString() {
- StringBuilder sb = new StringBuilder("Address[");
- sb.append("street=");
- sb.append(street);
- sb.append(", city=");
- sb.append(city);
- sb.append(", state=");
- sb.append(state);
- sb.append(", zipCode=");
- sb.append(zipCode);
- sb.append("]");
- return (sb.toString());
+ public String toString()
+ {
+ StringBuilder sb = new StringBuilder( "Address[" );
+ sb.append( "street=" );
+ sb.append( street );
+ sb.append( ", city=" );
+ sb.append( city );
+ sb.append( ", state=" );
+ sb.append( state );
+ sb.append( ", zipCode=" );
+ sb.append( zipCode );
+ sb.append( "]" );
+ return ( sb.toString() );
}
}
Modified: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/AlphaBean.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/AlphaBean.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/AlphaBean.java (original)
+++ commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/AlphaBean.java Thu May 12 18:03:26 2011
@@ -18,42 +18,54 @@
package org.apache.commons.digester3;
-public class AlphaBean implements Nameable {
+public class AlphaBean
+ implements Nameable
+{
private String name = "ALPHA";
-
+
private Nameable child;
+
private Nameable parent;
- public AlphaBean() {}
-
- public AlphaBean(String name) {
- setName(name);
+ public AlphaBean()
+ {
}
-
- public String getName() {
+
+ public AlphaBean( String name )
+ {
+ setName( name );
+ }
+
+ public String getName()
+ {
return name;
}
-
- public void setName(String name) {
+
+ public void setName( String name )
+ {
this.name = name;
}
- public void setParent(Nameable parent) {
+ public void setParent( Nameable parent )
+ {
this.parent = parent;
}
-
- public Nameable getParent() {
+
+ public Nameable getParent()
+ {
return parent;
}
-
- public void setChild(Nameable child) {
+
+ public void setChild( Nameable child )
+ {
this.child = child;
}
- public Nameable getChild() {
+ public Nameable getChild()
+ {
return child;
}
-
+
@Override
public String toString()
{