commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From simonetrip...@apache.org
Subject svn commit: r1102402 [3/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/commons...
Date Thu, 12 May 2011 18:03:33 GMT
Modified: commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/Digester.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/Digester.java?rev=1102402&r1=1102401&r2=1102402&view=diff
==============================================================================
--- commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/Digester.java (original)
+++ commons/sandbox/digester3/trunk/src/main/java/org/apache/commons/digester3/Digester.java Thu May 12 18:03:26 2011
@@ -18,7 +18,6 @@
 
 package org.apache.commons.digester3;
 
-
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -56,65 +55,61 @@ import org.xml.sax.SAXParseException;
 import org.xml.sax.XMLReader;
 import org.xml.sax.helpers.DefaultHandler;
 
-
-
-
 /**
- * <p>A <strong>Digester</strong> processes an XML input stream by matching a
- * series of element nesting patterns to execute Rules that have been added
- * prior to the start of parsing.</p>
- *
- * <p>See the <a href="package-summary.html#package_description">Digester
- * Developer Guide</a> for more information.</p>
- *
- * <p><strong>IMPLEMENTATION NOTE</strong> - A single Digester instance may
- * only be used within the context of a single thread at a time, and a call
- * to <code>parse()</code> must be completed before another can be initiated
- * even from the same thread.</p>
- * 
- * <p>A Digester instance should not be used for parsing more than one input
- * document. The problem is that the Digester class has quite a few member
- * variables whose values "evolve" as SAX events are received during a parse.
- * When reusing the Digester instance, all these members must be reset back
- * to their initial states before the second parse begins. The "clear()"
- * method makes a stab at resetting these, but it is actually rather a
- * difficult problem. If you are determined to reuse Digester instances, then
- * at the least you should call the clear() method before each parse, and must
- * call it if the Digester parse terminates due to an exception during a parse.
+ * <p>
+ * A <strong>Digester</strong> processes an XML input stream by matching a series of element nesting patterns to execute
+ * Rules that have been added prior to the start of parsing.
+ * </p>
+ * <p>
+ * See the <a href="package-summary.html#package_description">Digester Developer Guide</a> for more information.
+ * </p>
+ * <p>
+ * <strong>IMPLEMENTATION NOTE</strong> - A single Digester instance may only be used within the context of a single
+ * thread at a time, and a call to <code>parse()</code> must be completed before another can be initiated even from the
+ * same thread.
+ * </p>
+ * <p>
+ * A Digester instance should not be used for parsing more than one input document. The problem is that the Digester
+ * class has quite a few member variables whose values "evolve" as SAX events are received during a parse. When reusing
+ * the Digester instance, all these members must be reset back to their initial states before the second parse begins.
+ * The "clear()" method makes a stab at resetting these, but it is actually rather a difficult problem. If you are
+ * determined to reuse Digester instances, then at the least you should call the clear() method before each parse, and
+ * must call it if the Digester parse terminates due to an exception during a parse.
+ * </p>
+ * <p>
+ * <strong>LEGACY IMPLEMENTATION NOTE</strong> - When using the legacy XML schema support (instead of using the
+ * {@link Schema} class), a bug in Xerces 2.0.2 prevents the support of XML schema. You need Xerces 2.1/2.3 and up to
+ * make this class work with the legacy XML schema support.
+ * </p>
+ * <p>
+ * This package was inspired by the <code>XmlMapper</code> class that was part of Tomcat 3.0 and 3.1, but is organized
+ * somewhat differently.
  * </p>
- *
- * <p><strong>LEGACY IMPLEMENTATION NOTE</strong> - When using the legacy XML
- * schema support (instead of using the {@link Schema} class), a bug in
- * Xerces 2.0.2 prevents the support of XML schema. You need Xerces 2.1/2.3
- * and up to make this class work with the legacy XML schema support.</p>
- *
- * <p>This package was inspired by the <code>XmlMapper</code> class that was
- * part of Tomcat 3.0 and 3.1, but is organized somewhat differently.</p>
  */
 
-public class Digester extends DefaultHandler {
-
+public class Digester
+    extends DefaultHandler
+{
 
     // --------------------------------------------------------- Constructors
 
-
     /**
      * Construct a new Digester with default properties.
      */
-    public Digester() {
+    public Digester()
+    {
 
         super();
 
     }
 
-
     /**
-     * Construct a new Digester, allowing a SAXParser to be passed in.  This
-     * allows Digester to be used in environments which are unfriendly to
-     * JAXP1.1 (such as WebLogic 6.0). This may help in places where
-     * you are able to load JAXP 1.1 classes yourself.
+     * Construct a new Digester, allowing a SAXParser to be passed in. This allows Digester to be used in environments
+     * which are unfriendly to JAXP1.1 (such as WebLogic 6.0). This may help in places where you are able to load JAXP
+     * 1.1 classes yourself.
      */
-    public Digester(SAXParser parser) {
+    public Digester( SAXParser parser )
+    {
 
         super();
 
@@ -122,15 +117,13 @@ public class Digester extends DefaultHan
 
     }
 
-
     /**
-     * Construct a new Digester, allowing an XMLReader to be passed in.  This
-     * allows Digester to be used in environments which are unfriendly to
-     * JAXP1.1 (such as WebLogic 6.0).  Note that if you use this option you
-     * have to configure namespace and validation support yourself, as these
-     * properties only affect the SAXParser and emtpy constructor.
+     * Construct a new Digester, allowing an XMLReader to be passed in. This allows Digester to be used in environments
+     * which are unfriendly to JAXP1.1 (such as WebLogic 6.0). Note that if you use this option you have to configure
+     * namespace and validation support yourself, as these properties only affect the SAXParser and emtpy constructor.
      */
-    public Digester(XMLReader reader) {
+    public Digester( XMLReader reader )
+    {
 
         super();
 
@@ -138,68 +131,55 @@ public class Digester extends DefaultHan
 
     }
 
-
     // --------------------------------------------------- Instance Variables
 
-
     /**
      * The body text of the current element.
      */
     private StringBuilder bodyText = new StringBuilder();
 
-
     /**
      * The stack of body text string buffers for surrounding elements.
      */
     private final Stack<StringBuilder> bodyTexts = new Stack<StringBuilder>();
 
-
     /**
-     * Stack whose elements are List objects, each containing a list of
-     * Rule objects as returned from Rules.getMatch(). As each xml element
-     * in the input is entered, the matching rules are pushed onto this
-     * stack. After the end tag is reached, the matches are popped again.
-     * The depth of is stack is therefore exactly the same as the current
-     * "nesting" level of the input xml. 
-     *
+     * Stack whose elements are List objects, each containing a list of Rule objects as returned from Rules.getMatch().
+     * As each xml element in the input is entered, the matching rules are pushed onto this stack. After the end tag is
+     * reached, the matches are popped again. The depth of is stack is therefore exactly the same as the current
+     * "nesting" level of the input xml.
+     * 
      * @since 1.6
      */
     private final Stack<List<Rule>> matches = new Stack<List<Rule>>();
-    
+
     /**
-     * The class loader to use for instantiating application objects.
-     * If not specified, the context class loader, or the class loader
-     * used to load Digester itself, is used, based on the value of the
-     * <code>useContextClassLoader</code> variable.
+     * The class loader to use for instantiating application objects. If not specified, the context class loader, or the
+     * class loader used to load Digester itself, is used, based on the value of the <code>useContextClassLoader</code>
+     * variable.
      */
     private ClassLoader classLoader = null;
 
-
     /**
      * Has this Digester been configured yet.
      */
     private boolean configured = false;
 
-
     /**
      * The EntityResolver used by the SAX parser. By default it use this class
      */
     private EntityResolver entityResolver;
-    
+
     /**
-     * The URLs of entityValidator that have been registered, keyed by the public
-     * identifier that corresponds.
+     * The URLs of entityValidator that have been registered, keyed by the public identifier that corresponds.
      */
     private final HashMap<String, URL> entityValidator = new HashMap<String, URL>();
 
-
     /**
-     * The application-supplied error handler that is notified when parsing
-     * warnings, errors, or fatal errors occur.
+     * The application-supplied error handler that is notified when parsing warnings, errors, or fatal errors occur.
      */
     private ErrorHandler errorHandler = null;
 
-
     /**
      * The SAXParserFactory that is created the first time we need it.
      */
@@ -210,790 +190,746 @@ public class Digester extends DefaultHan
      */
     private Locator locator = null;
 
-
     /**
      * The current match pattern for nested element processing.
      */
     private String match = "";
 
-
     /**
      * Do we want a "namespace aware" parser.
      */
     private boolean namespaceAware = false;
 
-
     /**
-     * Registered namespaces we are currently processing.  The key is the
-     * namespace prefix that was declared in the document.  The value is an
-     * Stack of the namespace URIs this prefix has been mapped to --
-     * the top Stack element is the most current one.  (This architecture
-     * is required because documents can declare nested uses of the same
-     * prefix for different Namespace URIs).
+     * Registered namespaces we are currently processing. The key is the namespace prefix that was declared in the
+     * document. The value is an Stack of the namespace URIs this prefix has been mapped to -- the top Stack element is
+     * the most current one. (This architecture is required because documents can declare nested uses of the same prefix
+     * for different Namespace URIs).
      */
     private final HashMap<String, Stack<String>> namespaces = new HashMap<String, Stack<String>>();
 
-
     /**
      * Do we want a "XInclude aware" parser.
      */
     private boolean xincludeAware = false;
 
-
     /**
-     * The parameters stack being utilized by CallMethodRule and
-     * CallParamRule rules.
-     *
+     * The parameters stack being utilized by CallMethodRule and CallParamRule rules.
+     * 
      * @since 2.0
      */
     private final Stack<Object[]> params = new Stack<Object[]>();
 
-
     /**
      * The SAXParser we will use to parse the input stream.
      */
     private SAXParser parser = null;
 
-
     /**
-     * The public identifier of the DTD we are currently parsing under
-     * (if any).
+     * The public identifier of the DTD we are currently parsing under (if any).
      */
     private String publicId = null;
 
-
     /**
      * The XMLReader used to parse digester rules.
      */
     private XMLReader reader = null;
 
-
     /**
-     * The "root" element of the stack (in other words, the last object
-     * that was popped.
+     * The "root" element of the stack (in other words, the last object that was popped.
      */
     private Object root = null;
 
-
     /**
-     * The <code>Rules</code> implementation containing our collection of
-     * <code>Rule</code> instances and associated matching policy.  If not
-     * established before the first rule is added, a default implementation
-     * will be provided.
+     * The <code>Rules</code> implementation containing our collection of <code>Rule</code> instances and associated
+     * matching policy. If not established before the first rule is added, a default implementation will be provided.
      */
     private Rules rules = null;
 
     /**
      * The XML schema to use for validating an XML instance.
-     *
+     * 
      * @since 2.0
      */
     private Schema schema = null;
 
-
     /**
      * The object stack being constructed.
      */
     private final Stack<Object> stack = new Stack<Object>();
 
-
     /**
-     * Do we want to use the Context ClassLoader when loading classes
-     * for instantiating new objects.  Default is <code>false</code>.
+     * Do we want to use the Context ClassLoader when loading classes for instantiating new objects. Default is
+     * <code>false</code>.
      */
     private boolean useContextClassLoader = false;
 
-
     /**
      * Do we want to use a validating parser.
      */
     private boolean validating = false;
 
-
     /**
      * The Log to which most logging calls will be made.
      */
-    private Log log =
-        LogFactory.getLog("org.apache.commons.digester3.Digester");
-
+    private Log log = LogFactory.getLog( "org.apache.commons.digester3.Digester" );
 
     /**
      * The Log to which all SAX event related logging calls will be made.
      */
-    private Log saxLog =
-        LogFactory.getLog("org.apache.commons.digester3.Digester.sax");
-    
-        
+    private Log saxLog = LogFactory.getLog( "org.apache.commons.digester3.Digester.sax" );
+
     /**
      * The schema language supported. By default, we use this one.
      */
-    protected static final String W3C_XML_SCHEMA =
-        "http://www.w3.org/2001/XMLSchema";
-    
+    protected static final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";
+
     /**
-     * An optional class that substitutes values in attributes and body text.
-     * This may be null and so a null check is always required before use.
+     * An optional class that substitutes values in attributes and body text. This may be null and so a null check is
+     * always required before use.
      */
     private Substitutor substitutor;
-    
+
     /** Stacks used for interrule communication, indexed by name String */
     private final HashMap<String, Stack<Object>> stacksByName = new HashMap<String, Stack<Object>>();
-    
+
     /**
-     * If not null, then calls by the parser to this object's characters, 
-     * startElement, endElement and processingInstruction methods are 
-     * forwarded to the specified object. This is intended to allow rules
-     * to temporarily "take control" of the sax events. In particular, 
-     * this is used by NodeCreateRule.
+     * If not null, then calls by the parser to this object's characters, startElement, endElement and
+     * processingInstruction methods are forwarded to the specified object. This is intended to allow rules to
+     * temporarily "take control" of the sax events. In particular, this is used by NodeCreateRule.
      * <p>
      * See setCustomContentHandler.
      */
     private ContentHandler customContentHandler = null;
 
     /**
-     * Object which will receive callbacks for every pop/push action
-     * on the default stack or named stacks. 
+     * Object which will receive callbacks for every pop/push action on the default stack or named stacks.
      */
     private StackAction stackAction = null;
 
     // ------------------------------------------------------------- Properties
 
     /**
-     * Return the currently mapped namespace URI for the specified prefix,
-     * if any; otherwise return <code>null</code>.  These mappings come and
-     * go dynamically as the document is parsed.
-     *
+     * Return the currently mapped namespace URI for the specified prefix, if any; otherwise return <code>null</code>.
+     * These mappings come and go dynamically as the document is parsed.
+     * 
      * @param prefix Prefix to look up
      */
-    public String findNamespaceURI(String prefix) {
-        
-        Stack<String> nsStack = namespaces.get(prefix);
-        if (nsStack == null) {
+    public String findNamespaceURI( String prefix )
+    {
+
+        Stack<String> nsStack = namespaces.get( prefix );
+        if ( nsStack == null )
+        {
             return null;
         }
-        try {
-            return (nsStack.peek());
-        } catch (EmptyStackException e) {
+        try
+        {
+            return ( nsStack.peek() );
+        }
+        catch ( EmptyStackException e )
+        {
             return null;
         }
 
     }
 
-
     /**
-     * Return the class loader to be used for instantiating application objects
-     * when required.  This is determined based upon the following rules:
+     * Return the class loader to be used for instantiating application objects when required. This is determined based
+     * upon the following rules:
      * <ul>
      * <li>The class loader set by <code>setClassLoader()</code>, if any</li>
-     * <li>The thread context class loader, if it exists and the
-     *     <code>useContextClassLoader</code> property is set to true</li>
+     * <li>The thread context class loader, if it exists and the <code>useContextClassLoader</code> property is set to
+     * true</li>
      * <li>The class loader used to load the Digester class itself.
      * </ul>
      */
-    public ClassLoader getClassLoader() {
+    public ClassLoader getClassLoader()
+    {
 
-        if (this.classLoader != null) {
-            return (this.classLoader);
+        if ( this.classLoader != null )
+        {
+            return ( this.classLoader );
         }
-        if (this.useContextClassLoader) {
-            ClassLoader classLoader =
-                    Thread.currentThread().getContextClassLoader();
-            if (classLoader != null) {
-                return (classLoader);
+        if ( this.useContextClassLoader )
+        {
+            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+            if ( classLoader != null )
+            {
+                return ( classLoader );
             }
         }
-        return (this.getClass().getClassLoader());
+        return ( this.getClass().getClassLoader() );
 
     }
 
-
     /**
-     * Set the class loader to be used for instantiating application objects
-     * when required.
-     *
-     * @param classLoader The new class loader to use, or <code>null</code>
-     *  to revert to the standard rules
+     * Set the class loader to be used for instantiating application objects when required.
+     * 
+     * @param classLoader The new class loader to use, or <code>null</code> to revert to the standard rules
      */
-    public void setClassLoader(ClassLoader classLoader) {
+    public void setClassLoader( ClassLoader classLoader )
+    {
 
         this.classLoader = classLoader;
 
     }
 
-
     /**
      * Return the current depth of the element stack.
      */
-    public int getCount() {
+    public int getCount()
+    {
 
-        return (stack.size());
+        return ( stack.size() );
 
     }
 
-
     /**
      * Return the name of the XML element that is currently being processed.
      */
-    public String getCurrentElementName() {
+    public String getCurrentElementName()
+    {
 
         String elementName = match;
-        int lastSlash = elementName.lastIndexOf('/');
-        if (lastSlash >= 0) {
-            elementName = elementName.substring(lastSlash + 1);
+        int lastSlash = elementName.lastIndexOf( '/' );
+        if ( lastSlash >= 0 )
+        {
+            elementName = elementName.substring( lastSlash + 1 );
         }
-        return (elementName);
+        return ( elementName );
 
     }
 
-
     /**
      * Return the error handler for this Digester.
      */
-    public ErrorHandler getErrorHandler() {
+    public ErrorHandler getErrorHandler()
+    {
 
-        return (this.errorHandler);
+        return ( this.errorHandler );
 
     }
 
-
     /**
      * Set the error handler for this Digester.
-     *
+     * 
      * @param errorHandler The new error handler
      */
-    public void setErrorHandler(ErrorHandler errorHandler) {
+    public void setErrorHandler( ErrorHandler errorHandler )
+    {
 
         this.errorHandler = errorHandler;
 
     }
 
-
     /**
      * Return the SAXParserFactory we will use, creating one if necessary.
      */
-    public SAXParserFactory getFactory() {
+    public SAXParserFactory getFactory()
+    {
 
-        if (factory == null) {
+        if ( factory == null )
+        {
             factory = SAXParserFactory.newInstance();
-            factory.setNamespaceAware(namespaceAware);
-            factory.setXIncludeAware(xincludeAware);
-            factory.setValidating(validating);
-            factory.setSchema(schema);
+            factory.setNamespaceAware( namespaceAware );
+            factory.setXIncludeAware( xincludeAware );
+            factory.setValidating( validating );
+            factory.setSchema( schema );
         }
-        return (factory);
+        return ( factory );
 
     }
 
-
     /**
-     * Returns a flag indicating whether the requested feature is supported
-     * by the underlying implementation of <code>org.xml.sax.XMLReader</code>.
-     * See <a href="http://www.saxproject.org">the saxproject website</a>
-     * for information about the standard SAX2 feature flags.
-     *
+     * Returns a flag indicating whether the requested feature is supported by the underlying implementation of
+     * <code>org.xml.sax.XMLReader</code>. See <a href="http://www.saxproject.org">the saxproject website</a> for
+     * information about the standard SAX2 feature flags.
+     * 
      * @param feature Name of the feature to inquire about
-     *
-     * @exception ParserConfigurationException if a parser configuration error
-     *  occurs
-     * @exception SAXNotRecognizedException if the property name is
-     *  not recognized
-     * @exception SAXNotSupportedException if the property name is
-     *  recognized but not supported
+     * @exception ParserConfigurationException if a parser configuration error occurs
+     * @exception SAXNotRecognizedException if the property name is not recognized
+     * @exception SAXNotSupportedException if the property name is recognized but not supported
      */
-    public boolean getFeature(String feature)
-        throws ParserConfigurationException, SAXNotRecognizedException,
-        SAXNotSupportedException {
+    public boolean getFeature( String feature )
+        throws ParserConfigurationException, SAXNotRecognizedException, SAXNotSupportedException
+    {
 
-        return (getFactory().getFeature(feature));
+        return ( getFactory().getFeature( feature ) );
 
     }
 
-
     /**
-     * Sets a flag indicating whether the requested feature is supported
-     * by the underlying implementation of <code>org.xml.sax.XMLReader</code>.
-     * See <a href="http://www.saxproject.org">the saxproject website</a>
-     * for information about the standard SAX2 feature flags.  In order to be
-     * effective, this method must be called <strong>before</strong> the
-     * <code>getParser()</code> method is called for the first time, either
-     * directly or indirectly.
-     *
+     * Sets a flag indicating whether the requested feature is supported by the underlying implementation of
+     * <code>org.xml.sax.XMLReader</code>. See <a href="http://www.saxproject.org">the saxproject website</a> for
+     * information about the standard SAX2 feature flags. In order to be effective, this method must be called
+     * <strong>before</strong> the <code>getParser()</code> method is called for the first time, either directly or
+     * indirectly.
+     * 
      * @param feature Name of the feature to set the status for
      * @param value The new value for this feature
-     *
-     * @exception ParserConfigurationException if a parser configuration error
-     *  occurs
-     * @exception SAXNotRecognizedException if the property name is
-     *  not recognized
-     * @exception SAXNotSupportedException if the property name is
-     *  recognized but not supported
-     */
-    public void setFeature(String feature, boolean value)
-        throws ParserConfigurationException, SAXNotRecognizedException,
-        SAXNotSupportedException {
+     * @exception ParserConfigurationException if a parser configuration error occurs
+     * @exception SAXNotRecognizedException if the property name is not recognized
+     * @exception SAXNotSupportedException if the property name is recognized but not supported
+     */
+    public void setFeature( String feature, boolean value )
+        throws ParserConfigurationException, SAXNotRecognizedException, SAXNotSupportedException
+    {
 
-        getFactory().setFeature(feature, value);
+        getFactory().setFeature( feature, value );
 
     }
 
-
     /**
      * Return the current Logger associated with this instance of the Digester
      */
-    public Log getLogger() {
+    public Log getLogger()
+    {
 
         return log;
 
     }
 
-
     /**
      * Set the current logger for this Digester.
      */
-    public void setLogger(Log log) {
+    public void setLogger( Log log )
+    {
 
         this.log = log;
 
     }
 
     /**
-     * Gets the logger used for logging SAX-related information.
-     * <strong>Note</strong> the output is finely grained.
-     *
+     * Gets the logger used for logging SAX-related information. <strong>Note</strong> the output is finely grained.
+     * 
      * @since 1.6
      */
-    public Log getSAXLogger() {
-        
+    public Log getSAXLogger()
+    {
+
         return saxLog;
     }
-    
 
     /**
-     * Sets the logger used for logging SAX-related information.
-     * <strong>Note</strong> the output is finely grained.
+     * Sets the logger used for logging SAX-related information. <strong>Note</strong> the output is finely grained.
+     * 
      * @param saxLog Log, not null
-     *
      * @since 1.6
-     */    
-    public void setSAXLogger(Log saxLog) {
-    
+     */
+    public void setSAXLogger( Log saxLog )
+    {
+
         this.saxLog = saxLog;
     }
 
     /**
      * Return the current rule match path
      */
-    public String getMatch() {
+    public String getMatch()
+    {
 
         return match;
 
     }
 
-
     /**
      * Return the "namespace aware" flag for parsers we create.
      */
-    public boolean getNamespaceAware() {
+    public boolean getNamespaceAware()
+    {
 
-        return (this.namespaceAware);
+        return ( this.namespaceAware );
 
     }
 
-
     /**
      * Set the "namespace aware" flag for parsers we create.
-     *
+     * 
      * @param namespaceAware The new "namespace aware" flag
      */
-    public void setNamespaceAware(boolean namespaceAware) {
+    public void setNamespaceAware( boolean namespaceAware )
+    {
 
         this.namespaceAware = namespaceAware;
 
     }
 
-
     /**
-     * Return the XInclude-aware flag for parsers we create. XInclude
-     * functionality additionally requires namespace-awareness.
-     *
+     * Return the XInclude-aware flag for parsers we create. XInclude functionality additionally requires
+     * namespace-awareness.
+     * 
      * @return The XInclude-aware flag
-     *
      * @see #getNamespaceAware()
-     *
      * @since 2.0
      */
-    public boolean getXIncludeAware() {
+    public boolean getXIncludeAware()
+    {
 
-        return (this.xincludeAware);
+        return ( this.xincludeAware );
 
     }
 
-
     /**
-     * Set the XInclude-aware flag for parsers we create. This additionally
-     * requires namespace-awareness.
-     *
+     * Set the XInclude-aware flag for parsers we create. This additionally requires namespace-awareness.
+     * 
      * @param xincludeAware The new XInclude-aware flag
-     *
      * @see #setNamespaceAware(boolean)
-     *
      * @since 2.0
      */
-    public void setXIncludeAware(boolean xincludeAware) {
+    public void setXIncludeAware( boolean xincludeAware )
+    {
 
         this.xincludeAware = xincludeAware;
 
     }
 
-    
     /**
      * Set the publid id of the current file being parse.
+     * 
      * @param publicId the DTD/Schema public's id.
      */
-    public void setPublicId(String publicId){
+    public void setPublicId( String publicId )
+    {
         this.publicId = publicId;
     }
-    
-    
+
     /**
-     * Return the public identifier of the DTD we are currently
-     * parsing under, if any.
+     * Return the public identifier of the DTD we are currently parsing under, if any.
      */
-    public String getPublicId() {
+    public String getPublicId()
+    {
 
-        return (this.publicId);
+        return ( this.publicId );
 
     }
 
-
     /**
-     * Return the namespace URI that will be applied to all subsequently
-     * added <code>Rule</code> objects.
+     * Return the namespace URI that will be applied to all subsequently added <code>Rule</code> objects.
      */
-    public String getRuleNamespaceURI() {
+    public String getRuleNamespaceURI()
+    {
 
-        return (getRules().getNamespaceURI());
+        return ( getRules().getNamespaceURI() );
 
     }
 
-
     /**
-     * Set the namespace URI that will be applied to all subsequently
-     * added <code>Rule</code> objects.
-     *
-     * @param ruleNamespaceURI Namespace URI that must match on all
-     *  subsequently added rules, or <code>null</code> for matching
-     *  regardless of the current namespace URI
+     * Set the namespace URI that will be applied to all subsequently added <code>Rule</code> objects.
+     * 
+     * @param ruleNamespaceURI Namespace URI that must match on all subsequently added rules, or <code>null</code> for
+     *            matching regardless of the current namespace URI
      */
-    public void setRuleNamespaceURI(String ruleNamespaceURI) {
+    public void setRuleNamespaceURI( String ruleNamespaceURI )
+    {
 
-        getRules().setNamespaceURI(ruleNamespaceURI);
+        getRules().setNamespaceURI( ruleNamespaceURI );
 
     }
 
-
     /**
-     * Return the SAXParser we will use to parse the input stream.  If there
-     * is a problem creating the parser, return <code>null</code>.
+     * Return the SAXParser we will use to parse the input stream. If there is a problem creating the parser, return
+     * <code>null</code>.
      */
-    public SAXParser getParser() {
+    public SAXParser getParser()
+    {
 
         // Return the parser we already created (if any)
-        if (parser != null) {
-            return (parser);
+        if ( parser != null )
+        {
+            return ( parser );
         }
 
         // Create a new parser
-        try {
+        try
+        {
             parser = getFactory().newSAXParser();
-        } catch (Exception e) {
-            log.error("Digester.getParser: ", e);
-            return (null);
+        }
+        catch ( Exception e )
+        {
+            log.error( "Digester.getParser: ", e );
+            return ( null );
         }
 
-        return (parser);
+        return ( parser );
 
     }
 
-
     /**
-     * Return the current value of the specified property for the underlying
-     * <code>XMLReader</code> implementation.
-     * See <a href="http://www.saxproject.org">the saxproject website</a>
-     * for information about the standard SAX2 properties.
-     *
+     * Return the current value of the specified property for the underlying <code>XMLReader</code> implementation. See
+     * <a href="http://www.saxproject.org">the saxproject website</a> for information about the standard SAX2
+     * properties.
+     * 
      * @param property Property name to be retrieved
-     *
-     * @exception SAXNotRecognizedException if the property name is
-     *  not recognized
-     * @exception SAXNotSupportedException if the property name is
-     *  recognized but not supported
+     * @exception SAXNotRecognizedException if the property name is not recognized
+     * @exception SAXNotSupportedException if the property name is recognized but not supported
      */
-    public Object getProperty(String property)
-        throws SAXNotRecognizedException, SAXNotSupportedException {
+    public Object getProperty( String property )
+        throws SAXNotRecognizedException, SAXNotSupportedException
+    {
 
-        return (getParser().getProperty(property));
+        return ( getParser().getProperty( property ) );
 
     }
 
-
     /**
-     * Set the current value of the specified property for the underlying
-     * <code>XMLReader</code> implementation.
-     * See <a href="http://www.saxproject.org">the saxproject website</a>
-     * for information about the standard SAX2 properties.
-     *
+     * Set the current value of the specified property for the underlying <code>XMLReader</code> implementation. See <a
+     * href="http://www.saxproject.org">the saxproject website</a> for information about the standard SAX2 properties.
+     * 
      * @param property Property name to be set
      * @param value Property value to be set
-     *
-     * @exception SAXNotRecognizedException if the property name is
-     *  not recognized
-     * @exception SAXNotSupportedException if the property name is
-     *  recognized but not supported
+     * @exception SAXNotRecognizedException if the property name is not recognized
+     * @exception SAXNotSupportedException if the property name is recognized but not supported
      */
-    public void setProperty(String property, Object value)
-        throws SAXNotRecognizedException, SAXNotSupportedException {
+    public void setProperty( String property, Object value )
+        throws SAXNotRecognizedException, SAXNotSupportedException
+    {
 
-        getParser().setProperty(property, value);
+        getParser().setProperty( property, value );
 
     }
 
-
     /**
-     * Return the <code>Rules</code> implementation object containing our
-     * rules collection and associated matching policy.  If none has been
-     * established, a default implementation will be created and returned.
+     * Return the <code>Rules</code> implementation object containing our rules collection and associated matching
+     * policy. If none has been established, a default implementation will be created and returned.
      */
-    public Rules getRules() {
+    public Rules getRules()
+    {
 
-        if (this.rules == null) {
+        if ( this.rules == null )
+        {
             this.rules = new RulesBase();
-            this.rules.setDigester(this);
+            this.rules.setDigester( this );
         }
-        return (this.rules);
+        return ( this.rules );
 
     }
 
-    
     /**
-     * Set the <code>Rules</code> implementation object containing our
-     * rules collection and associated matching policy.
-     *
+     * Set the <code>Rules</code> implementation object containing our rules collection and associated matching policy.
+     * 
      * @param rules New Rules implementation
      */
-    public void setRules(Rules rules) {
+    public void setRules( Rules rules )
+    {
 
         this.rules = rules;
-        this.rules.setDigester(this);
+        this.rules.setDigester( this );
 
     }
 
-
     /**
      * Return the XML Schema used when parsing.
-     *
+     * 
      * @return The {@link Schema} instance in use.
-     *
      * @since 2.0
      */
-    public Schema getXMLSchema() {
+    public Schema getXMLSchema()
+    {
 
-        return (this.schema);
+        return ( this.schema );
 
     }
 
-
     /**
      * Set the XML Schema to be used when parsing.
-     *
+     * 
      * @param schema The {@link Schema} instance to use.
-     *
      * @since 2.0
      */
-    public void setXMLSchema(Schema schema){
+    public void setXMLSchema( Schema schema )
+    {
 
         this.schema = schema;
 
     }
 
-
     /**
      * Return the boolean as to whether the context classloader should be used.
      */
-    public boolean getUseContextClassLoader() {
+    public boolean getUseContextClassLoader()
+    {
 
         return useContextClassLoader;
 
     }
 
-
     /**
-     * Determine whether to use the Context ClassLoader (the one found by
-     * calling <code>Thread.currentThread().getContextClassLoader()</code>)
-     * to resolve/load classes that are defined in various rules.  If not
-     * using Context ClassLoader, then the class-loading defaults to
-     * using the calling-class' ClassLoader.
-     *
+     * Determine whether to use the Context ClassLoader (the one found by calling
+     * <code>Thread.currentThread().getContextClassLoader()</code>) to resolve/load classes that are defined in various
+     * rules. If not using Context ClassLoader, then the class-loading defaults to using the calling-class' ClassLoader.
+     * 
      * @param use determines whether to use Context ClassLoader.
      */
-    public void setUseContextClassLoader(boolean use) {
+    public void setUseContextClassLoader( boolean use )
+    {
 
         useContextClassLoader = use;
 
     }
 
-
     /**
      * Return the validating parser flag.
      */
-    public boolean getValidating() {
+    public boolean getValidating()
+    {
 
-        return (this.validating);
+        return ( this.validating );
 
     }
 
-
     /**
-     * Set the validating parser flag.  This must be called before
-     * <code>parse()</code> is called the first time.
-     *
+     * Set the validating parser flag. This must be called before <code>parse()</code> is called the first time.
+     * 
      * @param validating The new validating parser flag.
      */
-    public void setValidating(boolean validating) {
+    public void setValidating( boolean validating )
+    {
 
         this.validating = validating;
 
     }
 
-
     /**
-     * Return the XMLReader to be used for parsing the input document.
-     *
-     * FIX ME: there is a bug in JAXP/XERCES that prevent the use of a 
-     * parser that contains a schema with a DTD.
+     * Return the XMLReader to be used for parsing the input document. FIX ME: there is a bug in JAXP/XERCES that
+     * prevent the use of a parser that contains a schema with a DTD.
+     * 
      * @exception SAXException if no XMLReader can be instantiated
      */
-    public XMLReader getXMLReader() throws SAXException {
-        if (reader == null){
+    public XMLReader getXMLReader()
+        throws SAXException
+    {
+        if ( reader == null )
+        {
             reader = getParser().getXMLReader();
-        }        
-                               
-        reader.setDTDHandler(this);           
-        reader.setContentHandler(this);        
-        
-        if (entityResolver == null){
-            reader.setEntityResolver(this);
-        } else {
-            reader.setEntityResolver(entityResolver);           
         }
-        
-        reader.setErrorHandler(this);
+
+        reader.setDTDHandler( this );
+        reader.setContentHandler( this );
+
+        if ( entityResolver == null )
+        {
+            reader.setEntityResolver( this );
+        }
+        else
+        {
+            reader.setEntityResolver( entityResolver );
+        }
+
+        reader.setErrorHandler( this );
         return reader;
     }
 
     /**
      * Gets the <code>Substitutor</code> used to convert attributes and body text.
+     * 
      * @return Substitutor, null if not substitutions are to be performed.
      */
-    public Substitutor getSubstitutor() {
+    public Substitutor getSubstitutor()
+    {
         return substitutor;
     }
-    
-    /** 
+
+    /**
      * Sets the <code>Substitutor</code> to be used to convert attributes and body text.
-     * @param substitutor the Substitutor to be used to convert attributes and body text
-     * or null if not substitution of these values is to be performed.
+     * 
+     * @param substitutor the Substitutor to be used to convert attributes and body text or null if not substitution of
+     *            these values is to be performed.
      */
-    public void setSubstitutor(Substitutor substitutor) {
+    public void setSubstitutor( Substitutor substitutor )
+    {
         this.substitutor = substitutor;
     }
 
     /*
      * See setCustomContentHandler.
-     * 
-     * @since 1.7 
+     * @since 1.7
      */
-    public ContentHandler getCustomContentHandler() {
+    public ContentHandler getCustomContentHandler()
+    {
         return customContentHandler;
     }
 
-    /** 
-     * Redirects (or cancels redirecting) of SAX ContentHandler events to an
-     * external object.
-     * <p>
-     * When this object's customContentHandler is non-null, any SAX events
-     * received from the parser will simply be passed on to the specified 
-     * object instead of this object handling them. This allows Rule classes 
-     * to take control of the SAX event stream for a while in order to do 
-     * custom processing. Such a rule should save the old value before setting
-     * a new one, and restore the old value in order to resume normal digester
-     * processing.
+    /**
+     * Redirects (or cancels redirecting) of SAX ContentHandler events to an external object.
+     * <p>
+     * When this object's customContentHandler is non-null, any SAX events received from the parser will simply be
+     * passed on to the specified object instead of this object handling them. This allows Rule classes to take control
+     * of the SAX event stream for a while in order to do custom processing. Such a rule should save the old value
+     * before setting a new one, and restore the old value in order to resume normal digester processing.
      * <p>
      * An example of a Rule which needs this feature is NodeCreateRule.
      * <p>
-     * Note that saving the old value is probably not needed as it should always
-     * be null; a custom rule that wants to take control could only have been 
-     * called when there was no custom content handler. But it seems cleaner
-     * to properly save/restore the value and maybe some day this will come in
-     * useful.
+     * Note that saving the old value is probably not needed as it should always be null; a custom rule that wants to
+     * take control could only have been called when there was no custom content handler. But it seems cleaner to
+     * properly save/restore the value and maybe some day this will come in useful.
      * <p>
      * Note also that this is not quite equivalent to
+     * 
      * <pre>
-     * digester.getXMLReader().setContentHandler(handler)
+     * digester.getXMLReader().setContentHandler( handler )
      * </pre>
+     * 
      * for these reasons:
      * <ul>
-     * <li>Some xml parsers don't like having setContentHandler called after
-     * parsing has started. The Aelfred parser is one example.</li>
-     * <li>Directing the events via the Digester object potentially allows
-     * us to log information about those SAX events at the digester level.</li>
+     * <li>Some xml parsers don't like having setContentHandler called after parsing has started. The Aelfred parser is
+     * one example.</li>
+     * <li>Directing the events via the Digester object potentially allows us to log information about those SAX events
+     * at the digester level.</li>
      * </ul>
      * 
-     * @since 1.7 
+     * @since 1.7
      */
-    public void setCustomContentHandler(ContentHandler handler) {
+    public void setCustomContentHandler( ContentHandler handler )
+    {
         customContentHandler = handler;
     }
 
-    /** 
-     * Define a callback object which is invoked whever an object is pushed onto
-     * a digester object stack, or popped off one.
+    /**
+     * Define a callback object which is invoked whever an object is pushed onto a digester object stack, or popped off
+     * one.
      * 
      * @since 1.8
      */
-    public void setStackAction(StackAction stackAction) {
+    public void setStackAction( StackAction stackAction )
+    {
         this.stackAction = stackAction;
     }
 
     /**
-     * See setStackAction. 
+     * See setStackAction.
      * 
      * @since 1.8
      */
-    public StackAction getStackAction() {
+    public StackAction getStackAction()
+    {
         return stackAction;
     }
 
     /**
      * Get the most current namespaces for all prefixes.
-     *
-     * @return Map A map with namespace prefixes as keys and most current
-     *             namespace URIs for the corresponding prefixes as values
-     *
+     * 
+     * @return Map A map with namespace prefixes as keys and most current namespace URIs for the corresponding prefixes
+     *         as values
      * @since 1.8
      */
-    public Map<String, String> getCurrentNamespaces() {
-        if (!namespaceAware) {
-            log.warn("Digester is not namespace aware");
+    public Map<String, String> getCurrentNamespaces()
+    {
+        if ( !namespaceAware )
+        {
+            log.warn( "Digester is not namespace aware" );
         }
         Map<String, String> currentNamespaces = new HashMap<String, String>();
-        for (Map.Entry<String, Stack<String>> nsEntry : namespaces.entrySet()) {
-             try {
-                currentNamespaces.put(nsEntry.getKey(),
-                    nsEntry.getValue().peek());
-            } catch (RuntimeException e) {
+        for ( Map.Entry<String, Stack<String>> nsEntry : namespaces.entrySet() )
+        {
+            try
+            {
+                currentNamespaces.put( nsEntry.getKey(), nsEntry.getValue().peek() );
+            }
+            catch ( RuntimeException e )
+            {
                 // rethrow, after logging
-                log.error(e.getMessage(), e);
+                log.error( e.getMessage(), e );
                 throw e;
             }
         }
@@ -1002,62 +938,72 @@ public class Digester extends DefaultHan
 
     // ------------------------------------------------- ContentHandler Methods
 
-
     /**
-     * Process notification of character data received from the body of
-     * an XML element.
-     *
+     * Process notification of character data received from the body of an XML element.
+     * 
      * @param buffer The characters from the XML document
      * @param start Starting offset into the buffer
      * @param length Number of characters from the buffer
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void characters(char buffer[], int start, int length)
-            throws SAXException {
+    public void characters( char buffer[], int start, int length )
+        throws SAXException
+    {
 
-        if (customContentHandler != null) {
+        if ( customContentHandler != null )
+        {
             // forward calls instead of handling them here
-            customContentHandler.characters(buffer, start, length);
+            customContentHandler.characters( buffer, start, length );
             return;
         }
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("characters(" + new String(buffer, start, length) + ")");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "characters(" + new String( buffer, start, length ) + ")" );
         }
 
-        bodyText.append(buffer, start, length);
+        bodyText.append( buffer, start, length );
 
     }
 
-
     /**
      * Process notification of the end of the document being reached.
-     *
+     * 
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void endDocument() throws SAXException {
-
-        if (saxLog.isDebugEnabled()) {
-            if (getCount() > 1) {
-                saxLog.debug("endDocument():  " + getCount() +
-                             " elements left");
-            } else {
-                saxLog.debug("endDocument()");
+    public void endDocument()
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            if ( getCount() > 1 )
+            {
+                saxLog.debug( "endDocument():  " + getCount() + " elements left" );
+            }
+            else
+            {
+                saxLog.debug( "endDocument()" );
             }
         }
 
         // Fire "finish" events for all defined rules
-        for (Rule rule : getRules().rules()) {
-            try {
+        for ( Rule rule : getRules().rules() )
+        {
+            try
+            {
                 rule.finish();
-            } catch (Exception e) {
-                log.error("Finish event threw exception", e);
-                throw createSAXException(e);
-            } catch (Error e) {
-                log.error("Finish event threw error", e);
+            }
+            catch ( Exception e )
+            {
+                log.error( "Finish event threw exception", e );
+                throw createSAXException( e );
+            }
+            catch ( Error e )
+            {
+                log.error( "Finish event threw error", e );
                 throw e;
             }
         }
@@ -1067,200 +1013,230 @@ public class Digester extends DefaultHan
 
     }
 
-
     /**
      * Process notification of the end of an XML element being reached.
-     *
-     * @param namespaceURI - The Namespace URI, or the empty string if the
-     *   element has no Namespace URI or if Namespace processing is not
-     *   being performed.
-     * @param localName - The local name (without prefix), or the empty
-     *   string if Namespace processing is not being performed.
-     * @param qName - The qualified XML 1.0 name (with prefix), or the
-     *   empty string if qualified names are not available.
+     * 
+     * @param namespaceURI - The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace
+     *            processing is not being performed.
+     * @param localName - The local name (without prefix), or the empty string if Namespace processing is not being
+     *            performed.
+     * @param qName - The qualified XML 1.0 name (with prefix), or the empty string if qualified names are not
+     *            available.
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void endElement(String namespaceURI, String localName,
-                           String qName) throws SAXException {
+    public void endElement( String namespaceURI, String localName, String qName )
+        throws SAXException
+    {
 
-        if (customContentHandler != null) {
+        if ( customContentHandler != null )
+        {
             // forward calls instead of handling them here
-            customContentHandler.endElement(namespaceURI, localName, qName);
+            customContentHandler.endElement( namespaceURI, localName, qName );
             return;
         }
 
         boolean debug = log.isDebugEnabled();
 
-        if (debug) {
-            if (saxLog.isDebugEnabled()) {
-                saxLog.debug("endElement(" + namespaceURI + "," + localName +
-                        "," + qName + ")");
+        if ( debug )
+        {
+            if ( saxLog.isDebugEnabled() )
+            {
+                saxLog.debug( "endElement(" + namespaceURI + "," + localName + "," + qName + ")" );
             }
-            log.debug("  match='" + match + "'");
-            log.debug("  bodyText='" + bodyText + "'");
+            log.debug( "  match='" + match + "'" );
+            log.debug( "  bodyText='" + bodyText + "'" );
         }
 
-        // the actual element name is either in localName or qName, depending 
+        // the actual element name is either in localName or qName, depending
         // on whether the parser is namespace aware
         String name = localName;
-        if ((name == null) || (name.length() < 1)) {
+        if ( ( name == null ) || ( name.length() < 1 ) )
+        {
             name = qName;
         }
 
         // Fire "body" events for all relevant rules
         List<Rule> rules = matches.pop();
-        if ((rules != null) && (rules.size() > 0)) {
+        if ( ( rules != null ) && ( rules.size() > 0 ) )
+        {
             String bodyText = this.bodyText.toString();
             Substitutor substitutor = getSubstitutor();
-            if (substitutor!= null) {
-                bodyText = substitutor.substitute(bodyText);
-            }
-            for (int i = 0; i < rules.size(); i++) {
-                try {
-                    Rule rule = rules.get(i);
-                    if (debug) {
-                        log.debug("  Fire body() for " + rule);
+            if ( substitutor != null )
+            {
+                bodyText = substitutor.substitute( bodyText );
+            }
+            for ( int i = 0; i < rules.size(); i++ )
+            {
+                try
+                {
+                    Rule rule = rules.get( i );
+                    if ( debug )
+                    {
+                        log.debug( "  Fire body() for " + rule );
                     }
-                    rule.body(namespaceURI, name, bodyText);
-                } catch (Exception e) {
-                    log.error("Body event threw exception", e);
-                    throw createSAXException(e);
-                } catch (Error e) {
-                    log.error("Body event threw error", e);
+                    rule.body( namespaceURI, name, bodyText );
+                }
+                catch ( Exception e )
+                {
+                    log.error( "Body event threw exception", e );
+                    throw createSAXException( e );
+                }
+                catch ( Error e )
+                {
+                    log.error( "Body event threw error", e );
                     throw e;
                 }
             }
-        } else {
-            if (debug) {
-                log.debug("  No rules found matching '" + match + "'.");
+        }
+        else
+        {
+            if ( debug )
+            {
+                log.debug( "  No rules found matching '" + match + "'." );
             }
         }
 
         // Recover the body text from the surrounding element
         bodyText = bodyTexts.pop();
-        if (debug) {
-            log.debug("  Popping body text '" + bodyText.toString() + "'");
+        if ( debug )
+        {
+            log.debug( "  Popping body text '" + bodyText.toString() + "'" );
         }
 
         // Fire "end" events for all relevant rules in reverse order
-        if (rules != null) {
-            for (int i = 0; i < rules.size(); i++) {
-                int j = (rules.size() - i) - 1;
-                try {
-                    Rule rule = rules.get(j);
-                    if (debug) {
-                        log.debug("  Fire end() for " + rule);
+        if ( rules != null )
+        {
+            for ( int i = 0; i < rules.size(); i++ )
+            {
+                int j = ( rules.size() - i ) - 1;
+                try
+                {
+                    Rule rule = rules.get( j );
+                    if ( debug )
+                    {
+                        log.debug( "  Fire end() for " + rule );
                     }
-                    rule.end(namespaceURI, name);
-                } catch (Exception e) {
-                    log.error("End event threw exception", e);
-                    throw createSAXException(e);
-                } catch (Error e) {
-                    log.error("End event threw error", e);
+                    rule.end( namespaceURI, name );
+                }
+                catch ( Exception e )
+                {
+                    log.error( "End event threw exception", e );
+                    throw createSAXException( e );
+                }
+                catch ( Error e )
+                {
+                    log.error( "End event threw error", e );
                     throw e;
                 }
             }
         }
 
         // Recover the previous match expression
-        int slash = match.lastIndexOf('/');
-        if (slash >= 0) {
-            match = match.substring(0, slash);
-        } else {
+        int slash = match.lastIndexOf( '/' );
+        if ( slash >= 0 )
+        {
+            match = match.substring( 0, slash );
+        }
+        else
+        {
             match = "";
         }
 
     }
 
-
     /**
      * Process notification that a namespace prefix is going out of scope.
-     *
+     * 
      * @param prefix Prefix that is going out of scope
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void endPrefixMapping(String prefix) throws SAXException {
-
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("endPrefixMapping(" + prefix + ")");
+    public void endPrefixMapping( String prefix )
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "endPrefixMapping(" + prefix + ")" );
         }
 
         // Deregister this prefix mapping
-        Stack<String> stack = namespaces.get(prefix);
-        if (stack == null) {
+        Stack<String> stack = namespaces.get( prefix );
+        if ( stack == null )
+        {
             return;
         }
-        try {
+        try
+        {
             stack.pop();
-            if (stack.empty())
-                namespaces.remove(prefix);
-        } catch (EmptyStackException e) {
-            throw createSAXException("endPrefixMapping popped too many times");
+            if ( stack.empty() )
+                namespaces.remove( prefix );
+        }
+        catch ( EmptyStackException e )
+        {
+            throw createSAXException( "endPrefixMapping popped too many times" );
         }
 
     }
 
-
     /**
-     * Process notification of ignorable whitespace received from the body of
-     * an XML element.
-     *
+     * Process notification of ignorable whitespace received from the body of an XML element.
+     * 
      * @param buffer The characters from the XML document
      * @param start Starting offset into the buffer
      * @param len Number of characters from the buffer
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void ignorableWhitespace(char buffer[], int start, int len)
-            throws SAXException {
-
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("ignorableWhitespace(" +
-                    new String(buffer, start, len) + ")");
+    public void ignorableWhitespace( char buffer[], int start, int len )
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "ignorableWhitespace(" + new String( buffer, start, len ) + ")" );
         }
 
         // No processing required
 
     }
 
-
     /**
      * Process notification of a processing instruction that was encountered.
-     *
+     * 
      * @param target The processing instruction target
      * @param data The processing instruction data (if any)
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void processingInstruction(String target, String data)
-            throws SAXException {
+    public void processingInstruction( String target, String data )
+        throws SAXException
+    {
 
-        if (customContentHandler != null) {
+        if ( customContentHandler != null )
+        {
             // forward calls instead of handling them here
-            customContentHandler.processingInstruction(target, data);
+            customContentHandler.processingInstruction( target, data );
             return;
         }
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("processingInstruction('" + target + "','" + data + "')");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "processingInstruction('" + target + "','" + data + "')" );
         }
 
         // No processing is required
 
     }
 
-
     /**
      * Gets the document locator associated with our parser.
-     *
+     * 
      * @return the Locator supplied by the document parser
      */
-    public Locator getDocumentLocator() {
+    public Locator getDocumentLocator()
+    {
 
         return locator;
 
@@ -1268,14 +1244,16 @@ public class Digester extends DefaultHan
 
     /**
      * Sets the document locator associated with our parser.
-     *
+     * 
      * @param locator The new locator
      */
     @Override
-    public void setDocumentLocator(Locator locator) {
+    public void setDocumentLocator( Locator locator )
+    {
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("setDocumentLocator(" + locator + ")");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "setDocumentLocator(" + locator + ")" );
         }
 
         this.locator = locator;
@@ -1284,1382 +1262,1317 @@ public class Digester extends DefaultHan
 
     /**
      * Process notification of a skipped entity.
-     *
+     * 
      * @param name Name of the skipped entity
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void skippedEntity(String name) throws SAXException {
-
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("skippedEntity(" + name + ")");
+    public void skippedEntity( String name )
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "skippedEntity(" + name + ")" );
         }
 
         // No processing required
 
     }
 
-
     /**
      * Process notification of the beginning of the document being reached.
-     *
+     * 
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void startDocument() throws SAXException {
+    public void startDocument()
+        throws SAXException
+    {
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("startDocument()");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "startDocument()" );
         }
 
-        // ensure that the digester is properly configured, as 
+        // ensure that the digester is properly configured, as
         // the digester could be used as a SAX ContentHandler
         // rather than via the parse() methods.
         configure();
     }
 
-
     /**
      * Process notification of the start of an XML element being reached.
-     *
-     * @param namespaceURI The Namespace URI, or the empty string if the element
-     *   has no Namespace URI or if Namespace processing is not being performed.
-     * @param localName The local name (without prefix), or the empty
-     *   string if Namespace processing is not being performed.
-     * @param qName The qualified name (with prefix), or the empty
-     *   string if qualified names are not available.\
-     * @param list The attributes attached to the element. If there are
-     *   no attributes, it shall be an empty Attributes object. 
+     * 
+     * @param namespaceURI The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace
+     *            processing is not being performed.
+     * @param localName The local name (without prefix), or the empty string if Namespace processing is not being
+     *            performed.
+     * @param qName The qualified name (with prefix), or the empty string if qualified names are not available.\
+     * @param list The attributes attached to the element. If there are no attributes, it shall be an empty Attributes
+     *            object.
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void startElement(String namespaceURI, String localName,
-                             String qName, Attributes list)
-            throws SAXException {
+    public void startElement( String namespaceURI, String localName, String qName, Attributes list )
+        throws SAXException
+    {
         boolean debug = log.isDebugEnabled();
-        
-        if (customContentHandler != null) {
+
+        if ( customContentHandler != null )
+        {
             // forward calls instead of handling them here
-            customContentHandler.startElement(namespaceURI, localName, qName, list);
+            customContentHandler.startElement( namespaceURI, localName, qName, list );
             return;
         }
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("startElement(" + namespaceURI + "," + localName + "," +
-                    qName + ")");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "startElement(" + namespaceURI + "," + localName + "," + qName + ")" );
         }
-        
+
         // Save the body text accumulated for our surrounding element
-        bodyTexts.push(bodyText);
-        if (debug) {
-            log.debug("  Pushing body text '" + bodyText.toString() + "'");
+        bodyTexts.push( bodyText );
+        if ( debug )
+        {
+            log.debug( "  Pushing body text '" + bodyText.toString() + "'" );
         }
         bodyText = new StringBuilder();
 
-        // the actual element name is either in localName or qName, depending 
+        // the actual element name is either in localName or qName, depending
         // on whether the parser is namespace aware
         String name = localName;
-        if ((name == null) || (name.length() < 1)) {
+        if ( ( name == null ) || ( name.length() < 1 ) )
+        {
             name = qName;
         }
 
         // Compute the current matching rule
-        StringBuilder sb = new StringBuilder(match);
-        if (match.length() > 0) {
-            sb.append('/');
+        StringBuilder sb = new StringBuilder( match );
+        if ( match.length() > 0 )
+        {
+            sb.append( '/' );
         }
-        sb.append(name);
+        sb.append( name );
         match = sb.toString();
-        if (debug) {
-            log.debug("  New match='" + match + "'");
+        if ( debug )
+        {
+            log.debug( "  New match='" + match + "'" );
         }
 
         // Fire "begin" events for all relevant rules
-        List<Rule> rules = getRules().match(namespaceURI, match);
-        matches.push(rules);
-        if ((rules != null) && (rules.size() > 0)) {
+        List<Rule> rules = getRules().match( namespaceURI, match );
+        matches.push( rules );
+        if ( ( rules != null ) && ( rules.size() > 0 ) )
+        {
             Substitutor substitutor = getSubstitutor();
-            if (substitutor!= null) {
-                list = substitutor.substitute(list);
-            }
-            for (int i = 0; i < rules.size(); i++) {
-                try {
-                    Rule rule = rules.get(i);
-                    if (debug) {
-                        log.debug("  Fire begin() for " + rule);
+            if ( substitutor != null )
+            {
+                list = substitutor.substitute( list );
+            }
+            for ( int i = 0; i < rules.size(); i++ )
+            {
+                try
+                {
+                    Rule rule = rules.get( i );
+                    if ( debug )
+                    {
+                        log.debug( "  Fire begin() for " + rule );
                     }
-                    rule.begin(namespaceURI, name, list);
-                } catch (Exception e) {
-                    log.error("Begin event threw exception", e);
-                    throw createSAXException(e);
-                } catch (Error e) {
-                    log.error("Begin event threw error", e);
+                    rule.begin( namespaceURI, name, list );
+                }
+                catch ( Exception e )
+                {
+                    log.error( "Begin event threw exception", e );
+                    throw createSAXException( e );
+                }
+                catch ( Error e )
+                {
+                    log.error( "Begin event threw error", e );
                     throw e;
                 }
             }
-        } else {
-            if (debug) {
-                log.debug("  No rules found matching '" + match + "'.");
+        }
+        else
+        {
+            if ( debug )
+            {
+                log.debug( "  No rules found matching '" + match + "'." );
             }
         }
 
     }
 
-
     /**
      * Process notification that a namespace prefix is coming in to scope.
-     *
+     * 
      * @param prefix Prefix that is being declared
      * @param namespaceURI Corresponding namespace URI being mapped to
-     *
      * @exception SAXException if a parsing error is to be reported
      */
     @Override
-    public void startPrefixMapping(String prefix, String namespaceURI)
-            throws SAXException {
-
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("startPrefixMapping(" + prefix + "," + namespaceURI + ")");
+    public void startPrefixMapping( String prefix, String namespaceURI )
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "startPrefixMapping(" + prefix + "," + namespaceURI + ")" );
         }
 
         // Register this prefix mapping
-        Stack<String> stack = namespaces.get(prefix);
-        if (stack == null) {
+        Stack<String> stack = namespaces.get( prefix );
+        if ( stack == null )
+        {
             stack = new Stack<String>();
-            namespaces.put(prefix, stack);
+            namespaces.put( prefix, stack );
         }
-        stack.push(namespaceURI);
+        stack.push( namespaceURI );
 
     }
 
-
     // ----------------------------------------------------- DTDHandler Methods
 
-
     /**
      * Receive notification of a notation declaration event.
-     *
+     * 
      * @param name The notation name
      * @param publicId The public identifier (if any)
      * @param systemId The system identifier (if any)
      */
     @Override
-    public void notationDecl(String name, String publicId, String systemId) {
+    public void notationDecl( String name, String publicId, String systemId )
+    {
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("notationDecl(" + name + "," + publicId + "," +
-                    systemId + ")");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "notationDecl(" + name + "," + publicId + "," + systemId + ")" );
         }
 
     }
 
-
     /**
      * Receive notification of an unparsed entity declaration event.
-     *
+     * 
      * @param name The unparsed entity name
      * @param publicId The public identifier (if any)
      * @param systemId The system identifier (if any)
      * @param notation The name of the associated notation
      */
     @Override
-    public void unparsedEntityDecl(String name, String publicId,
-                                   String systemId, String notation) {
+    public void unparsedEntityDecl( String name, String publicId, String systemId, String notation )
+    {
 
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("unparsedEntityDecl(" + name + "," + publicId + "," +
-                    systemId + "," + notation + ")");
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "unparsedEntityDecl(" + name + "," + publicId + "," + systemId + "," + notation + ")" );
         }
 
     }
 
-
     // ----------------------------------------------- EntityResolver Methods
 
     /**
-     * Set the <code>EntityResolver</code> used by SAX when resolving
-     * public id and system id.
-     * This must be called before the first call to <code>parse()</code>.
+     * Set the <code>EntityResolver</code> used by SAX when resolving public id and system id. This must be called
+     * before the first call to <code>parse()</code>.
+     * 
      * @param entityResolver a class that implement the <code>EntityResolver</code> interface.
      */
-    public void setEntityResolver(EntityResolver entityResolver){
+    public void setEntityResolver( EntityResolver entityResolver )
+    {
         this.entityResolver = entityResolver;
     }
-    
-    
+
     /**
      * Return the Entity Resolver used by the SAX parser.
+     * 
      * @return Return the Entity Resolver used by the SAX parser.
      */
-    public EntityResolver getEntityResolver(){
+    public EntityResolver getEntityResolver()
+    {
         return entityResolver;
     }
 
     /**
      * Resolve the requested external entity.
-     *
+     * 
      * @param publicId The public identifier of the entity being referenced
      * @param systemId The system identifier of the entity being referenced
-     *
      * @exception SAXException if a parsing exception occurs
-     * 
      */
     @Override
-    public InputSource resolveEntity(String publicId, String systemId)
-            throws SAXException {     
-                
-        if (saxLog.isDebugEnabled()) {
-            saxLog.debug("resolveEntity('" + publicId + "', '" + systemId + "')");
+    public InputSource resolveEntity( String publicId, String systemId )
+        throws SAXException
+    {
+
+        if ( saxLog.isDebugEnabled() )
+        {
+            saxLog.debug( "resolveEntity('" + publicId + "', '" + systemId + "')" );
         }
-        
-        if (publicId != null)
+
+        if ( publicId != null )
             this.publicId = publicId;
-                                       
+
         // Has this system identifier been registered?
         URL entityURL = null;
-        if (publicId != null) {
-            entityURL = entityValidator.get(publicId);
+        if ( publicId != null )
+        {
+            entityURL = entityValidator.get( publicId );
         }
-         
+
         // Redirect the schema location to a local destination
-        if (entityURL == null && systemId != null){
-            entityURL = entityValidator.get(systemId);
-        } 
+        if ( entityURL == null && systemId != null )
+        {
+            entityURL = entityValidator.get( systemId );
+        }
 
-        if (entityURL == null) { 
-            if (systemId == null) {
+        if ( entityURL == null )
+        {
+            if ( systemId == null )
+            {
                 // cannot resolve
-                if (log.isDebugEnabled()) {
-                    log.debug(" Cannot resolve null entity, returning null InputSource");
+                if ( log.isDebugEnabled() )
+                {
+                    log.debug( " Cannot resolve null entity, returning null InputSource" );
                 }
-                return (null);
-                
+                return ( null );
+
             }
             // try to resolve using system ID
-            if (log.isDebugEnabled()) {
-                log.debug(" Trying to resolve using system ID '" + systemId + "'");
-            } 
-            try {
-                entityURL = new URL(systemId);
-            } catch (MalformedURLException e) {
-                throw new IllegalArgumentException("Malformed URL '" + systemId
-                    + "' : " + e.getMessage());
+            if ( log.isDebugEnabled() )
+            {
+                log.debug( " Trying to resolve using system ID '" + systemId + "'" );
+            }
+            try
+            {
+                entityURL = new URL( systemId );
+            }
+            catch ( MalformedURLException e )
+            {
+                throw new IllegalArgumentException( "Malformed URL '" + systemId + "' : " + e.getMessage() );
             }
         }
-        
+
         // Return an input source to our alternative URL
-        if (log.isDebugEnabled()) {
-            log.debug(" Resolving to alternate DTD '" + entityURL + "'");
-        }  
-        
-        try {
-            return createInputSourceFromURL(entityURL);
-        } catch (Exception e) {
-            throw createSAXException(e);
+        if ( log.isDebugEnabled() )
+        {
+            log.debug( " Resolving to alternate DTD '" + entityURL + "'" );
         }
-    }
 
+        try
+        {
+            return createInputSourceFromURL( entityURL );
+        }
+        catch ( Exception e )
+        {
+            throw createSAXException( e );
+        }
+    }
 
     // ------------------------------------------------- ErrorHandler Methods
 
-
     /**
-     * Forward notification of a parsing error to the application supplied
-     * error handler (if any).
-     *
+     * Forward notification of a parsing error to the application supplied error handler (if any).
+     * 
      * @param exception The error information
-     *
      * @exception SAXException if a parsing exception occurs
      */
     @Override
-    public void error(SAXParseException exception) throws SAXException {
+    public void error( SAXParseException exception )
+        throws SAXException
+    {
 
-        log.error("Parse Error at line " + exception.getLineNumber() +
-                " column " + exception.getColumnNumber() + ": " +
-                exception.getMessage(), exception);
-        if (errorHandler != null) {
-            errorHandler.error(exception);
+        log.error( "Parse Error at line " + exception.getLineNumber() + " column " + exception.getColumnNumber() + ": "
+            + exception.getMessage(), exception );
+        if ( errorHandler != null )
+        {
+            errorHandler.error( exception );
         }
 
     }
 
-
     /**
-     * Forward notification of a fatal parsing error to the application
-     * supplied error handler (if any).
-     *
+     * Forward notification of a fatal parsing error to the application supplied error handler (if any).
+     * 
      * @param exception The fatal error information
-     *
      * @exception SAXException if a parsing exception occurs
      */
     @Override
-    public void fatalError(SAXParseException exception) throws SAXException {
+    public void fatalError( SAXParseException exception )
+        throws SAXException
+    {
 
-        log.error("Parse Fatal Error at line " + exception.getLineNumber() +
-                " column " + exception.getColumnNumber() + ": " +
-                exception.getMessage(), exception);
-        if (errorHandler != null) {
-            errorHandler.fatalError(exception);
+        log.error( "Parse Fatal Error at line " + exception.getLineNumber() + " column " + exception.getColumnNumber()
+            + ": " + exception.getMessage(), exception );
+        if ( errorHandler != null )
+        {
+            errorHandler.fatalError( exception );
         }
 
     }
 
-
     /**
-     * Forward notification of a parse warning to the application supplied
-     * error handler (if any).
-     *
+     * Forward notification of a parse warning to the application supplied error handler (if any).
+     * 
      * @param exception The warning information
-     *
      * @exception SAXException if a parsing exception occurs
      */
     @Override
-    public void warning(SAXParseException exception) throws SAXException {
-         if (errorHandler != null) {
-            log.warn("Parse Warning Error at line " + exception.getLineNumber() +
-                " column " + exception.getColumnNumber() + ": " +
-                exception.getMessage(), exception);
-            
-            errorHandler.warning(exception);
+    public void warning( SAXParseException exception )
+        throws SAXException
+    {
+        if ( errorHandler != null )
+        {
+            log.warn( "Parse Warning Error at line " + exception.getLineNumber() + " column "
+                          + exception.getColumnNumber() + ": " + exception.getMessage(), exception );
+
+            errorHandler.warning( exception );
         }
 
     }
 
-
     // ------------------------------------------------------- Public Methods
 
-
     /**
-     * Parse the content of the specified file using this Digester.  Returns
-     * the root element from the object stack (if any).
-     *
+     * Parse the content of the specified file using this Digester. Returns the root element from the object stack (if
+     * any).
+     * 
      * @param file File containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
      */
-    public <T> T parse(File file) throws IOException, SAXException {
-
-        if (file == null) {
-            throw new IllegalArgumentException("File to parse is null");
+    public <T> T parse( File file )
+        throws IOException, SAXException
+    {
+
+        if ( file == null )
+        {
+            throw new IllegalArgumentException( "File to parse is null" );
         }
 
         configure();
-        InputSource input = new InputSource(new FileInputStream(file));
-        input.setSystemId(file.toURI().toURL().toString());
-        getXMLReader().parse(input);
+        InputSource input = new InputSource( new FileInputStream( file ) );
+        input.setSystemId( file.toURI().toURL().toString() );
+        getXMLReader().parse( input );
         cleanup();
-        return (this.<T>getRoot());
+        return ( this.<T> getRoot() );
+
+    }
 
-    }   
     /**
-     * Parse the content of the specified input source using this Digester.
-     * Returns the root element from the object stack (if any).
-     *
+     * Parse the content of the specified input source using this Digester. Returns the root element from the object
+     * stack (if any).
+     * 
      * @param input Input source containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
      */
-    public <T> T parse(InputSource input) throws IOException, SAXException {
- 
-        if (input == null) {
-            throw new IllegalArgumentException("InputSource to parse is null");
+    public <T> T parse( InputSource input )
+        throws IOException, SAXException
+    {
+
+        if ( input == null )
+        {
+            throw new IllegalArgumentException( "InputSource to parse is null" );
         }
 
         configure();
-        getXMLReader().parse(input);
+        getXMLReader().parse( input );
         cleanup();
-        return this.<T>getRoot();
+        return this.<T> getRoot();
 
     }
 
-
     /**
-     * Parse the content of the specified input stream using this Digester.
-     * Returns the root element from the object stack (if any).
-     *
+     * Parse the content of the specified input stream using this Digester. Returns the root element from the object
+     * stack (if any).
+     * 
      * @param input Input stream containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
      */
-    public <T> T parse(InputStream input) throws IOException, SAXException {
-
-        if (input == null) {
-            throw new IllegalArgumentException("InputStream to parse is null");
+    public <T> T parse( InputStream input )
+        throws IOException, SAXException
+    {
+
+        if ( input == null )
+        {
+            throw new IllegalArgumentException( "InputStream to parse is null" );
         }
 
         configure();
-        InputSource is = new InputSource(input);
-        getXMLReader().parse(is);
+        InputSource is = new InputSource( input );
+        getXMLReader().parse( is );
         cleanup();
-        return (this.<T>getRoot());
+        return ( this.<T> getRoot() );
 
     }
 
-
     /**
-     * Parse the content of the specified reader using this Digester.
-     * Returns the root element from the object stack (if any).
-     *
+     * Parse the content of the specified reader using this Digester. Returns the root element from the object stack (if
+     * any).
+     * 
      * @param reader Reader containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
      */
-    public <T> T parse(Reader reader) throws IOException, SAXException {
-
-        if (reader == null) {
-            throw new IllegalArgumentException("Reader to parse is null");
+    public <T> T parse( Reader reader )
+        throws IOException, SAXException
+    {
+
+        if ( reader == null )
+        {
+            throw new IllegalArgumentException( "Reader to parse is null" );
         }
 
         configure();
-        InputSource is = new InputSource(reader);
-        getXMLReader().parse(is);
+        InputSource is = new InputSource( reader );
+        getXMLReader().parse( is );
         cleanup();
-        return (this.<T>getRoot());
+        return ( this.<T> getRoot() );
 
     }
 
-
     /**
-     * Parse the content of the specified URI using this Digester.
-     * Returns the root element from the object stack (if any).
-     *
+     * Parse the content of the specified URI using this Digester. Returns the root element from the object stack (if
+     * any).
+     * 
      * @param uri URI containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
      */
-    public <T> T parse(String uri) throws IOException, SAXException {
-
-        if (uri == null) {
-            throw new IllegalArgumentException("String URI to parse is null");
+    public <T> T parse( String uri )
+        throws IOException, SAXException
+    {
+
+        if ( uri == null )
+        {
+            throw new IllegalArgumentException( "String URI to parse is null" );
         }
 
         configure();
-        InputSource is = createInputSourceFromURL(uri);
-        getXMLReader().parse(is);
+        InputSource is = createInputSourceFromURL( uri );
+        getXMLReader().parse( is );
         cleanup();
-        return (this.<T>getRoot());
+        return ( this.<T> getRoot() );
 
     }
 
-
     /**
-     * Parse the content of the specified URL using this Digester.
-     * Returns the root element from the object stack (if any).
-     *
+     * Parse the content of the specified URL using this Digester. Returns the root element from the object stack (if
+     * any).
+     * 
      * @param url URL containing the XML data to be parsed
-     *
      * @exception IOException if an input/output error occurs
      * @exception SAXException if a parsing exception occurs
-     *
      * @since 1.8
      */
-    public <T> T parse(URL url) throws IOException, SAXException {
-
-        if (url == null) {
-            throw new IllegalArgumentException("URL to parse is null");
+    public <T> T parse( URL url )
+        throws IOException, SAXException
+    {
+
+        if ( url == null )
+        {
+            throw new IllegalArgumentException( "URL to parse is null" );
         }
 
         configure();
-        InputSource is = createInputSourceFromURL(url);
-        getXMLReader().parse(is);
+        InputSource is = createInputSourceFromURL( url );
+        getXMLReader().parse( is );
         cleanup();
-        return (this.<T>getRoot());
+        return ( this.<T> getRoot() );
 
     }
 
-
     /**
-     * <p>Register the specified DTD URL for the specified public identifier.
-     * This must be called before the first call to <code>parse()</code>.
-     * </p><p>
-     * <code>Digester</code> contains an internal <code>EntityResolver</code>
-     * implementation. This maps <code>PUBLICID</code>'s to URLs 
-     * (from which the resource will be loaded). A common use case for this
-     * method is to register local URLs (possibly computed at runtime by a 
-     * classloader) for DTDs. This allows the performance advantage of using
-     * a local version without having to ensure every <code>SYSTEM</code>
-     * URI on every processed xml document is local. This implementation provides
-     * only basic functionality. If more sophisticated features are required,
-     * using {@link #setEntityResolver} to set a custom resolver is recommended.
-     * </p><p>
-     * <strong>Note:</strong> This method will have no effect when a custom 
-     * <code>EntityResolver</code> has been set. (Setting a custom 
-     * <code>EntityResolver</code> overrides the internal implementation.) 
+     * <p>
+     * Register the specified DTD URL for the specified public identifier. This must be called before the first call to
+     * <code>parse()</code>.
+     * </p>
+     * <p>
+     * <code>Digester</code> contains an internal <code>EntityResolver</code> implementation. This maps
+     * <code>PUBLICID</code>'s to URLs (from which the resource will be loaded). A common use case for this method is to
+     * register local URLs (possibly computed at runtime by a classloader) for DTDs. This allows the performance
+     * advantage of using a local version without having to ensure every <code>SYSTEM</code> URI on every processed xml
+     * document is local. This implementation provides only basic functionality. If more sophisticated features are
+     * required, using {@link #setEntityResolver} to set a custom resolver is recommended.
      * </p>
+     * <p>

[... 2063 lines stripped ...]


Mime
View raw message