You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by si...@apache.org on 2011/05/12 20:03:33 UTC
svn commit: r1102402 [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...
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 ...]