commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From simonetrip...@apache.org
Subject 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...
Date Thu, 12 May 2011 18:03:33 GMT
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()
     {



Mime
View raw message