- * Returns the QName of this attribute which represents the
- * local name, the qualified name and the Namespace.
- *
- *
- * @return the QName associated with this attribute
- */
- QName getQName();
+ /**
+ * Returns the QName of this attribute which represents the
+ * local name, the qualified name and the Namespace.
+ *
+ * @return the QName associated with this attribute
+ */
+ QName getQName();
- /**
- *
- * Returns the Namespace of this element if one exists
- * otherwise null is returned returned.
- *
- *
- * @return the Namespace associated with this node
- */
- Namespace getNamespace();
+ /**
+ * Returns the Namespace of this element if one exists
+ * otherwise null is returned returned.
+ *
+ * @return the Namespace associated with this node
+ */
+ Namespace getNamespace();
- /**
- *
- * Sets the Namespace of this element or if this element is
- * read only then an UnsupportedOperationException is thrown.
- *
- *
- * @param namespace
- * is the Namespace to associate with this element
- */
- void setNamespace(Namespace namespace);
+ /**
+ * Sets the Namespace of this element or if this element is
+ * read only then an UnsupportedOperationException is thrown.
+ *
+ * @param namespace is the Namespace to associate with this element
+ */
+ void setNamespace(Namespace namespace);
- /**
- *
- * Returns the namespace prefix of this element if one exists otherwise an
- * empty String is returned.
- *
- *
- * @return the prefix of the Namespace of this element or an
- * empty String
- */
- String getNamespacePrefix();
+ /**
+ * Returns the namespace prefix of this element if one exists otherwise an
+ * empty String is returned.
+ *
+ * @return the prefix of the Namespace of this element or an
+ * empty String
+ */
+ String getNamespacePrefix();
- /**
- *
- * Returns the URI mapped to the namespace of this element if one exists
- * otherwise an empty String is returned.
- *
- *
- * @return the URI for the Namespace of this element or an
- * empty String
- */
- String getNamespaceURI();
+ /**
+ * Returns the URI mapped to the namespace of this element if one exists
+ * otherwise an empty String is returned.
+ *
+ * @return the URI for the Namespace of this element or an
+ * empty String
+ */
+ String getNamespaceURI();
- /**
- *
- * Returns the fully qualified name of this element.
- *
- *
- *
- * This will be the same as the value returned from {@link Node#getName()}
- * if this element has no namespace attached to this element or an
- * expression of the form
- *
- *
- * getNamespacePrefix() + ":" + getName()
- *
- *
- * will be returned.
- *
- *
- * @return the fully qualified name of the element
- */
- String getQualifiedName();
+ /**
+ * Returns the fully qualified name of this element.
+ *
+ * This will be the same as the value returned from {@link Node#getName()}
+ * if this element has no namespace attached to this element or an
+ * expression of the form
+ *
+ * getNamespacePrefix() + ":" + getName()
+ *
+ * will be returned.
+ *
+ * @return the fully qualified name of the element
+ */
+ String getQualifiedName();
- /**
- *
- * Returns the value of the attribute. This method returns the same value as
- * the {@link Node#getText()}method.
- *
- *
- * @return the value of the attribute
- */
- String getValue();
+ /**
+ * Returns the value of the attribute. This method returns the same value as
+ * the {@link Node#getText()}method.
+ *
+ * @return the value of the attribute
+ */
+ String getValue();
- /**
- *
- * Sets the value of this attribute or this method will throw an
- * UnsupportedOperationException if it is read-only.
- *
- *
- * @param value
- * is the new value of this attribute
- */
- void setValue(String value);
+ /**
+ * Sets the value of this attribute or this method will throw an
+ * UnsupportedOperationException if it is read-only.
+ *
+ * @param value is the new value of this attribute
+ */
+ void setValue(String value);
- /**
- *
- * Accesses the data of this attribute which may implement data typing
- * bindings such as XML Schema or Java Bean
- * bindings or will return the same value as {@link Node#getText()}.
- *
- *
- * @return the attribute data
- */
- Object getData();
+ /**
+ * Accesses the data of this attribute which may implement data typing
+ * bindings such as XML Schema or Java Bean
+ * bindings or will return the same value as {@link Node#getText()}.
+ *
+ * @return the attribute data
+ */
+ Object getData();
- /**
- *
- * Sets the data value of this attribute if this element supports data
- * binding or calls {@link Node#setText(String)}if it doesn't.
- *
- *
- * @param data
- * the attribute data
- */
- void setData(Object data);
+ /**
+ * Sets the data value of this attribute if this element supports data
+ * binding or calls {@link Node#setText(String)}if it doesn't.
+ *
+ * @param data the attribute data
+ */
+ void setData(Object data);
}
/*
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/Branch.java b/fine-org-dom4j/src/main/java/org/dom4j/Branch.java
index 4074a588d..c7d36c2f6 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/Branch.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/Branch.java
@@ -11,306 +11,263 @@ import java.util.Iterator;
import java.util.List;
/**
- *
* Branch interface defines the common behaviour for Nodes which
* can contain child nodes (content) such as XML elements and documents. This
* interface allows both elements and documents to be treated in a polymorphic
* manner when changing or navigating child nodes (content).
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.32 $
*/
+@SuppressWarnings("unused")
public interface Branch extends Node {
- /**
- * Returns the Node at the specified index position.
- *
- * @param index
- * the index of the node to return.
- *
- * @return the Node at the specified position.
- *
- * @throws IndexOutOfBoundsException
- * if the index is out of range (index < 0 || index >=
- * {@link Branch#nodeCount()}).
- */
- Node node(int index) throws IndexOutOfBoundsException;
+ /**
+ * Returns the Node at the specified index position.
+ *
+ * @param index the index of the node to return.
+ * @return the Node at the specified position.
+ * @throws IndexOutOfBoundsException if the index is out of range (index < 0 || index >=
+ * {@link Branch#nodeCount()}).
+ */
+ Node node(int index) throws IndexOutOfBoundsException;
- /**
- * Returns the index of the given node if it is a child node of this branch
- * or -1 if the given node is not a child node.
- *
- * @param node
- * the content child node to find.
- *
- * @return the index of the given node starting at 0 or -1 if the node is
- * not a child node of this branch
- */
- int indexOf(Node node);
+ /**
+ * Returns the index of the given node if it is a child node of this branch
+ * or -1 if the given node is not a child node.
+ *
+ * @param node the content child node to find.
+ * @return the index of the given node starting at 0 or -1 if the node is
+ * not a child node of this branch
+ */
+ int indexOf(Node node);
- /**
- * Returns the number of Node instances that this branch
- * contains.
- *
- * @return the number of nodes this branch contains
- */
- int nodeCount();
+ /**
+ * Returns the number of Node instances that this branch
+ * contains.
+ *
+ * @return the number of nodes this branch contains
+ */
+ int nodeCount();
- /**
- * Returns the element of the given ID attribute value. If this tree is
- * capable of understanding which attribute value should be used for the ID
- * then it should be used, otherwise this method should return null.
- *
- * @param elementID
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- */
- Element elementByID(String elementID);
+ /**
+ * Returns the element of the given ID attribute value. If this tree is
+ * capable of understanding which attribute value should be used for the ID
+ * then it should be used, otherwise this method should return null.
+ *
+ * @param elementID DOCUMENT ME!
+ * @return DOCUMENT ME!
+ */
+ Element elementByID(String elementID);
- /**
- *
- * Returns the content nodes of this branch as a backed {@link List}so that
- * the content of this branch may be modified directly using the
- * {@link List}interface. The List is backed by the
- * Branch so that changes to the list are reflected in the
- * branch and vice versa.
- *
- *
- * @return the nodes that this branch contains as a List
- */
- List content();
+ /**
+ * Returns the content nodes of this branch as a backed {@link List}so that
+ * the content of this branch may be modified directly using the
+ * {@link List}interface. The List is backed by the
+ * Branch so that changes to the list are reflected in the
+ * branch and vice versa.
+ *
+ * @return the nodes that this branch contains as a List
+ */
+ List content();
- /**
- * Returns an iterator through the content nodes of this branch
- *
- * @return an iterator through the content nodes of this branch
- */
- Iterator nodeIterator();
+ /**
+ * Returns an iterator through the content nodes of this branch
+ *
+ * @return an iterator through the content nodes of this branch
+ */
+ Iterator nodeIterator();
- /**
- * Sets the contents of this branch as a List of
- * Node instances.
- *
- * @param content
- * is the list of nodes to use as the content for this branch.
- */
- void setContent(List content);
+ /**
+ * Sets the contents of this branch as a List of
+ * Node instances.
+ *
+ * @param content is the list of nodes to use as the content for this branch.
+ */
+ void setContent(List content);
- /**
- * Appends the content of the given branch to this branch instance. This
- * method behaves like the {@link
- * java.util.Collection#addAll(java.util.Collection)} method.
- *
- * @param branch
- * is the branch whose content will be added to me.
- */
- void appendContent(Branch branch);
+ /**
+ * Appends the content of the given branch to this branch instance. This
+ * method behaves like the {@link
+ * java.util.Collection#addAll(java.util.Collection)} method.
+ *
+ * @param branch is the branch whose content will be added to me.
+ */
+ void appendContent(Branch branch);
- /**
- * Clears the content for this branch, removing any Node
- * instances this branch may contain.
- */
- void clearContent();
+ /**
+ * Clears the content for this branch, removing any Node
+ * instances this branch may contain.
+ */
+ void clearContent();
- /**
- *
- * Returns a list of all the processing instructions in this branch. The
- * list is backed by this branch so that changes to the list will be
- * reflected in the branch but the reverse is not the case.
- *
- *
- * @return a backed list of the processing instructions
- */
- List processingInstructions();
+ /**
+ * Returns a list of all the processing instructions in this branch. The
+ * list is backed by this branch so that changes to the list will be
+ * reflected in the branch but the reverse is not the case.
+ *
+ * @return a backed list of the processing instructions
+ */
+ List processingInstructions();
- /**
- *
- * Returns a list of the processing instructions for the given target. The
- * list is backed by this branch so that changes to the list will be
- * reflected in the branch but the reverse is not the case.
- *
- *
- * @param target
- * DOCUMENT ME!
- *
- * @return a backed list of the processing instructions
- */
- List processingInstructions(String target);
+ /**
+ * Returns a list of the processing instructions for the given target. The
+ * list is backed by this branch so that changes to the list will be
+ * reflected in the branch but the reverse is not the case.
+ *
+ * @param target DOCUMENT ME!
+ * @return a backed list of the processing instructions
+ */
+ List processingInstructions(String target);
- /**
- * DOCUMENT ME!
- *
- * @param target
- * DOCUMENT ME!
- *
- * @return the processing instruction for the given target
- */
- ProcessingInstruction processingInstruction(String target);
+ /**
+ * DOCUMENT ME!
+ *
+ * @param target DOCUMENT ME!
+ * @return the processing instruction for the given target
+ */
+ ProcessingInstruction processingInstruction(String target);
- /**
- * Sets all the processing instructions for this branch
- *
- * @param listOfPIs
- * DOCUMENT ME!
- */
- void setProcessingInstructions(List listOfPIs);
+ /**
+ * Sets all the processing instructions for this branch
+ *
+ * @param listOfPIs DOCUMENT ME!
+ */
+ void setProcessingInstructions(List listOfPIs);
- /**
- * Adds a new Element node with the given name to this branch
- * and returns a reference to the new node.
- *
- * @param name
- * is the name for the Element node.
- *
- * @return the newly added Element node.
- */
- Element addElement(String name);
+ /**
+ * Adds a new Element node with the given name to this branch
+ * and returns a reference to the new node.
+ *
+ * @param name is the name for the Element node.
+ * @return the newly added Element node.
+ */
+ Element addElement(String name);
- /**
- * Adds a new Element node with the given {@link QName}to
- * this branch and returns a reference to the new node.
- *
- * @param qname
- * is the qualified name for the Element node.
- *
- * @return the newly added Element node.
- */
- Element addElement(QName qname);
+ /**
+ * Adds a new Element node with the given {@link QName}to
+ * this branch and returns a reference to the new node.
+ *
+ * @param qname is the qualified name for the Element node.
+ * @return the newly added Element node.
+ */
+ Element addElement(QName qname);
- /**
- * Adds a new Element node with the given qualified name and
- * namespace URI to this branch and returns a reference to the new node.
- *
- * @param qualifiedName
- * is the fully qualified name of the Element
- * @param namespaceURI
- * is the URI of the namespace to use
- *
- * @return the newly added Element node.
- */
- Element addElement(String qualifiedName, String namespaceURI);
+ /**
+ * Adds a new Element node with the given qualified name and
+ * namespace URI to this branch and returns a reference to the new node.
+ *
+ * @param qualifiedName is the fully qualified name of the Element
+ * @param namespaceURI is the URI of the namespace to use
+ * @return the newly added Element node.
+ */
+ Element addElement(String qualifiedName, String namespaceURI);
- /**
- * Removes the processing instruction for the given target if it exists
- *
- * @param target
- * DOCUMENT ME!
- *
- * @return true if a processing instruction was removed else false
- */
- boolean removeProcessingInstruction(String target);
+ /**
+ * Removes the processing instruction for the given target if it exists
+ *
+ * @param target DOCUMENT ME!
+ * @return true if a processing instruction was removed else false
+ */
+ boolean removeProcessingInstruction(String target);
- /**
- * Adds the given Node or throws {@link IllegalAddException}
- * if the given node is not of a valid type. This is a polymorphic method
- * which will call the typesafe method for the node type such as
- * add(Element) or add(Comment).
- *
- * @param node
- * is the given node to add
- */
- void add(Node node);
+ /**
+ * Adds the given Node or throws {@link IllegalAddException}
+ * if the given node is not of a valid type. This is a polymorphic method
+ * which will call the typesafe method for the node type such as
+ * add(Element) or add(Comment).
+ *
+ * @param node is the given node to add
+ */
+ void add(Node node);
- /**
- * Adds the given Comment to this branch. If the given node
- * already has a parent defined then an IllegalAddException
- * will be thrown.
- *
- * @param comment
- * is the comment to be added
- */
- void add(Comment comment);
+ /**
+ * Adds the given Comment to this branch. If the given node
+ * already has a parent defined then an IllegalAddException
+ * will be thrown.
+ *
+ * @param comment is the comment to be added
+ */
+ void add(Comment comment);
- /**
- * Adds the given Element to this branch. If the given node
- * already has a parent defined then an IllegalAddException
- * will be thrown.
- *
- * @param element
- * is the element to be added
- */
- void add(Element element);
+ /**
+ * Adds the given Element to this branch. If the given node
+ * already has a parent defined then an IllegalAddException
+ * will be thrown.
+ *
+ * @param element is the element to be added
+ */
+ void add(Element element);
- /**
- * Adds the given ProcessingInstruction to this branch. If
- * the given node already has a parent defined then an
- * IllegalAddException will be thrown.
- *
- * @param pi
- * is the processing instruction to be added
- */
- void add(ProcessingInstruction pi);
+ /**
+ * Adds the given ProcessingInstruction to this branch. If
+ * the given node already has a parent defined then an
+ * IllegalAddException will be thrown.
+ *
+ * @param pi is the processing instruction to be added
+ */
+ void add(ProcessingInstruction pi);
- /**
- * Removes the given Node if the node is an immediate child
- * of this branch. If the given node is not an immediate child of this
- * branch then the {@link Node#detach()}method should be used instead. This
- * is a polymorphic method which will call the typesafe method for the node
- * type such as remove(Element) or remove(Comment).
- *
- * @param node
- * is the given node to be removed
- *
- * @return true if the node was removed
- */
- boolean remove(Node node);
+ /**
+ * Removes the given Node if the node is an immediate child
+ * of this branch. If the given node is not an immediate child of this
+ * branch then the {@link Node#detach()}method should be used instead. This
+ * is a polymorphic method which will call the typesafe method for the node
+ * type such as remove(Element) or remove(Comment).
+ *
+ * @param node is the given node to be removed
+ * @return true if the node was removed
+ */
+ boolean remove(Node node);
- /**
- * Removes the given Comment if the node is an immediate
- * child of this branch. If the given node is not an immediate child of this
- * branch then the {@link Node#detach()}method should be used instead.
- *
- * @param comment
- * is the comment to be removed
- *
- * @return true if the comment was removed
- */
- boolean remove(Comment comment);
+ /**
+ * Removes the given Comment if the node is an immediate
+ * child of this branch. If the given node is not an immediate child of this
+ * branch then the {@link Node#detach()}method should be used instead.
+ *
+ * @param comment is the comment to be removed
+ * @return true if the comment was removed
+ */
+ boolean remove(Comment comment);
- /**
- * Removes the given Element if the node is an immediate
- * child of this branch. If the given node is not an immediate child of this
- * branch then the {@link Node#detach()}method should be used instead.
- *
- * @param element
- * is the element to be removed
- *
- * @return true if the element was removed
- */
- boolean remove(Element element);
+ /**
+ * Removes the given Element if the node is an immediate
+ * child of this branch. If the given node is not an immediate child of this
+ * branch then the {@link Node#detach()}method should be used instead.
+ *
+ * @param element is the element to be removed
+ * @return true if the element was removed
+ */
+ boolean remove(Element element);
- /**
- * Removes the given ProcessingInstruction if the node is an
- * immediate child of this branch. If the given node is not an immediate
- * child of this branch then the {@link Node#detach()}method should be used
- * instead.
- *
- * @param pi
- * is the processing instruction to be removed
- *
- * @return true if the processing instruction was removed
- */
- boolean remove(ProcessingInstruction pi);
+ /**
+ * Removes the given ProcessingInstruction if the node is an
+ * immediate child of this branch. If the given node is not an immediate
+ * child of this branch then the {@link Node#detach()}method should be used
+ * instead.
+ *
+ * @param pi is the processing instruction to be removed
+ * @return true if the processing instruction was removed
+ */
+ boolean remove(ProcessingInstruction pi);
- /**
- * Puts all Text nodes in the full depth of the sub-tree
- * underneath this Node, including attribute nodes, into a
- * "normal" form where only structure (e.g., elements, comments, processing
- * instructions, CDATA sections, and entity references) separates
- * Text nodes, i.e., there are neither adjacent
- * Text nodes nor empty Text nodes. This can
- * be used to ensure that the DOM view of a document is the same as if it
- * were saved and re-loaded, and is useful when operations (such as XPointer
- * lookups) that depend on a particular document tree structure are to be
- * used.In cases where the document contains CDATASections,
- * the normalize operation alone may not be sufficient, since XPointers do
- * not differentiate between Text nodes and
- * CDATASection nodes.
- *
- * @since DOM Level 2
- */
- void normalize();
+ /**
+ * Puts all Text nodes in the full depth of the sub-tree
+ * underneath this Node, including attribute nodes, into a
+ * "normal" form where only structure (e.g., elements, comments, processing
+ * instructions, CDATA sections, and entity references) separates
+ * Text nodes, i.e., there are neither adjacent
+ * Text nodes nor empty Text nodes. This can
+ * be used to ensure that the DOM view of a document is the same as if it
+ * were saved and re-loaded, and is useful when operations (such as XPointer
+ * lookups) that depend on a particular document tree structure are to be
+ * used.In cases where the document contains CDATASections,
+ * the normalize operation alone may not be sufficient, since XPointers do
+ * not differentiate between Text nodes and
+ * CDATASection nodes.
+ *
+ * @since DOM Level 2
+ */
+ void normalize();
}
/*
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/CDATA.java b/fine-org-dom4j/src/main/java/org/dom4j/CDATA.java
index d6816106a..8db6aeedf 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/CDATA.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/CDATA.java
@@ -8,13 +8,12 @@
package org.dom4j;
/**
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.14 $
*/
+@SuppressWarnings("unused")
public interface Document extends Branch {
/**
* Returns the root {@link Element}for this document.
@@ -70,7 +69,7 @@ public interface Document extends Branch {
*
* @return this Document instance.
*/
- Document addProcessingInstruction(String target, Map data);
+ Document addProcessingInstruction(String target, Map data);
/**
* Adds a DOCTYPE declaration to this document
@@ -124,15 +123,13 @@ public interface Document extends Branch {
* when the Document was created in memory) or when the implementation does
* not support this operation.
*
- *
* The way this encoding is retrieved also depends on the way the XML source
* is parsed. For instance, if the SAXReader is used and if the underlying
* XMLReader implementation support the
* org.xml.sax.ext.Locator2 interface, the result returned by
* this method is specified by the getEncoding() method of
* that interface.
- *
- *
+ *
* @return The encoding of this document, as stated in the XML declaration,
* or null if unknown.
*
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/DocumentException.java b/fine-org-dom4j/src/main/java/org/dom4j/DocumentException.java
index 2feb890be..2c7b5f027 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/DocumentException.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/DocumentException.java
@@ -7,78 +7,32 @@
package org.dom4j;
-import java.io.PrintStream;
-import java.io.PrintWriter;
-
/**
- *
- * DocumentException is a nested Exception which may be thrown
- * during the processing of a DOM4J document.
- *
- *
+ * DocumentException is a nested Exception which may be thrown during the processing of a DOM4J document.
+ *
* @author James Strachan
- * @version $Revision$
+ * @author Filip Jirsák
*/
public class DocumentException extends Exception {
- /** A wrapped Throwable */
- private Throwable nestedException;
public DocumentException() {
- super("Error occurred in DOM4J application.");
}
public DocumentException(String message) {
super(message);
}
- public DocumentException(Throwable nestedException) {
- super(nestedException.getMessage());
- this.nestedException = nestedException;
+ public DocumentException(String message, Throwable cause) {
+ super(message, cause);
}
- public DocumentException(String message, Throwable nestedException) {
- super(message);
- this.nestedException = nestedException;
+ public DocumentException(Throwable cause) {
+ super(cause);
}
+ @Deprecated
public Throwable getNestedException() {
- return nestedException;
- }
-
- public String getMessage() {
- if (nestedException != null) {
- return super.getMessage() + " Nested exception: "
- + nestedException.getMessage();
- } else {
- return super.getMessage();
- }
- }
-
- public void printStackTrace() {
- super.printStackTrace();
-
- if (nestedException != null) {
- System.err.print("Nested exception: ");
- nestedException.printStackTrace();
- }
- }
-
- public void printStackTrace(PrintStream out) {
- super.printStackTrace(out);
-
- if (nestedException != null) {
- out.println("Nested exception: ");
- nestedException.printStackTrace(out);
- }
- }
-
- public void printStackTrace(PrintWriter writer) {
- super.printStackTrace(writer);
-
- if (nestedException != null) {
- writer.println("Nested exception: ");
- nestedException.printStackTrace(writer);
- }
+ return null;
}
}
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/DocumentFactory.java b/fine-org-dom4j/src/main/java/org/dom4j/DocumentFactory.java
index 2571a3b40..9aaaa11cb 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/DocumentFactory.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/DocumentFactory.java
@@ -32,28 +32,25 @@ import org.dom4j.xpath.XPathPattern;
import org.jaxen.VariableContext;
/**
- *
* DocumentFactory is a collection of factory methods to allow
* easy custom building of DOM4J trees. The default tree that is built uses a
* doubly linked tree.
- *
- *
- *
+ *
* The tree built allows full XPath expressions from anywhere on the tree.
- *
- *
+ *
* @author James Strachan
*/
+@SuppressWarnings("unused")
public class DocumentFactory implements Serializable {
- private static SingletonStrategy singleton = null;
+ private static SingletonStrategy singleton = null;
protected transient QNameCache cache;
- /** Default namespace prefix -> URI mappings for XPath expressions to use */
- private Map xpathNamespaceURIs;
+ /** Default namespace prefix → URI mappings for XPath expressions to use */
+ private Map xpathNamespaceURIs;
- private static SingletonStrategy createSingleton() {
- SingletonStrategy result = null;
+ private static SingletonStrategy createSingleton() {
+ SingletonStrategy result;
String documentFactoryClassName;
try {
@@ -67,10 +64,10 @@ public class DocumentFactory implements Serializable {
String singletonClass = System.getProperty(
"org.dom4j.DocumentFactory.singleton.strategy",
"org.dom4j.util.SimpleSingleton");
- Class clazz = Class.forName(singletonClass);
- result = (SingletonStrategy) clazz.newInstance();
+ Class clazz = (Class) Class.forName(singletonClass);
+ result = clazz.newInstance();
} catch (Exception e) {
- result = new SimpleSingleton();
+ result = new SimpleSingleton();
}
result.setSingletonClassName(documentFactoryClassName);
@@ -83,18 +80,16 @@ public class DocumentFactory implements Serializable {
}
/**
- *
* Access to singleton implementation of DocumentFactory which is used if no
* DocumentFactory is specified when building using the standard builders.
- *
- *
+ *
* @return the default singleon instance
*/
public static synchronized DocumentFactory getInstance() {
if (singleton == null) {
singleton = createSingleton();
}
- return (DocumentFactory) singleton.instance();
+ return singleton.instance();
}
// Factory methods
@@ -121,10 +116,7 @@ public class DocumentFactory implements Serializable {
// createDocument() method.
Document answer = createDocument();
- if (answer instanceof AbstractDocument) {
- ((AbstractDocument) answer).setXMLEncoding(encoding);
- }
-
+ answer.setXMLEncoding(encoding);
return answer;
}
@@ -191,7 +183,7 @@ public class DocumentFactory implements Serializable {
}
public ProcessingInstruction createProcessingInstruction(String target,
- Map data) {
+ Map data) {
return new DefaultProcessingInstruction(target, data);
}
@@ -324,7 +316,7 @@ public class DocumentFactory implements Serializable {
*
* @return DOCUMENT ME!
*/
- public List getQNames() {
+ public List getQNames() {
return cache.getQNames();
}
@@ -337,7 +329,7 @@ public class DocumentFactory implements Serializable {
* namespace URI. This value could well be null to indicate no
* namespace URIs are being mapped.
*/
- public Map getXPathNamespaceURIs() {
+ public Map getXPathNamespaceURIs() {
return xpathNamespaceURIs;
}
@@ -349,7 +341,7 @@ public class DocumentFactory implements Serializable {
* @param namespaceURIs
* DOCUMENT ME!
*/
- public void setXPathNamespaceURIs(Map namespaceURIs) {
+ public void setXPathNamespaceURIs(Map namespaceURIs) {
this.xpathNamespaceURIs = namespaceURIs;
}
@@ -372,10 +364,10 @@ public class DocumentFactory implements Serializable {
try {
// I'll use the current class loader
// that loaded me to avoid problems in J2EE and web apps
- Class theClass = Class.forName(className, true,
+ Class theClass = (Class) Class.forName(className, true,
DocumentFactory.class.getClassLoader());
- return (DocumentFactory) theClass.newInstance();
+ return theClass.newInstance();
} catch (Throwable e) {
System.out.println("WARNING: Cannot load DocumentFactory: "
+ className);
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/DocumentHelper.java b/fine-org-dom4j/src/main/java/org/dom4j/DocumentHelper.java
index 35f31bc1e..865a51a17 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/DocumentHelper.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/DocumentHelper.java
@@ -18,16 +18,16 @@ import org.dom4j.rule.Pattern;
import org.jaxen.VariableContext;
import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
/**
- *
* DocumentHelper is a collection of helper methods for using
* DOM4J.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.26 $
*/
+@SuppressWarnings("unused")
public final class DocumentHelper {
private DocumentHelper() {
}
@@ -89,7 +89,7 @@ public final class DocumentHelper {
}
public static ProcessingInstruction createProcessingInstruction(String pi,
- Map data) {
+ Map data) {
return getDocumentFactory().createProcessingInstruction(pi, data);
}
@@ -107,12 +107,12 @@ public final class DocumentHelper {
* XPath XPath instance using the singleton {@link
* DocumentFactory}.
*
- *
+ *
* @param xpathExpression
* is the XPath expression to create
- *
+ *
* @return a new XPath instance
- *
+ *
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
@@ -127,14 +127,14 @@ public final class DocumentHelper {
* XPath XPath instance using the singleton {@link
* DocumentFactory}.
*
- *
+ *
* @param xpathExpression
* is the XPath expression to create
* @param context
* is the variable context to use when evaluating the XPath
- *
+ *
* @return a new XPath instance
- *
+ *
* @throws InvalidXPathException
* if the XPath expression is invalid
*/
@@ -150,10 +150,10 @@ public final class DocumentHelper {
* filter expressions occur within XPath expressions such as
* self::node()[ filterExpression ]
*
- *
+ *
* @param xpathFilterExpression
* is the XPath filter expression to create
- *
+ *
* @return a new NodeFilter instance
*/
public static NodeFilter createXPathFilter(String xpathFilterExpression) {
@@ -166,10 +166,10 @@ public final class DocumentHelper {
* an XSLT style {@link Pattern}instance which can then be used in an XSLT
* processing model.
*
- *
+ *
* @param xpathPattern
* is the XPath pattern expression to create
- *
+ *
* @return a new Pattern instance
*/
public static Pattern createPattern(String xpathPattern) {
@@ -182,15 +182,15 @@ public final class DocumentHelper {
* {@link List}of {@link Node}instances appending all the results together
* into a single list.
*
- *
+ *
* @param xpathFilterExpression
* is the XPath filter expression to evaluate
* @param nodes
* is the list of nodes on which to evalute the XPath
- *
+ *
* @return the results of all the XPath evaluations as a single list
*/
- public static List selectNodes(String xpathFilterExpression, List nodes) {
+ public static List selectNodes(String xpathFilterExpression, List nodes) {
XPath xpath = createXPath(xpathFilterExpression);
return xpath.selectNodes(nodes);
@@ -202,15 +202,15 @@ public final class DocumentHelper {
* {@link List}of {@link Node}instances appending all the results together
* into a single list.
*
- *
+ *
* @param xpathFilterExpression
* is the XPath filter expression to evaluate
* @param node
* is the Node on which to evalute the XPath
- *
+ *
* @return the results of all the XPath evaluations as a single list
*/
- public static List selectNodes(String xpathFilterExpression, Node node) {
+ public static List selectNodes(String xpathFilterExpression, Node node) {
XPath xpath = createXPath(xpathFilterExpression);
return xpath.selectNodes(node);
@@ -221,13 +221,13 @@ public final class DocumentHelper {
* sort sorts the given List of Nodes using an XPath
* expression as a {@link java.util.Comparator}.
*
- *
+ *
* @param list
* is the list of Nodes to sort
* @param xpathExpression
* is the XPath expression used for comparison
*/
- public static void sort(List list, String xpathExpression) {
+ public static void sort(List list, String xpathExpression) {
XPath xpath = createXPath(xpathExpression);
xpath.sort(list);
}
@@ -238,7 +238,7 @@ public final class DocumentHelper {
* expression as a {@link java.util.Comparator}and optionally removing
* duplicates.
*
- *
+ *
* @param list
* is the list of Nodes to sort
* @param expression
@@ -247,7 +247,7 @@ public final class DocumentHelper {
* if true then duplicate values (using the sortXPath for
* comparisions) will be removed from the List
*/
- public static void sort(List list, String expression, boolean distinct) {
+ public static void sort(List list, String expression, boolean distinct) {
XPath xpath = createXPath(expression);
xpath.sort(list, distinct);
}
@@ -257,25 +257,26 @@ public final class DocumentHelper {
* parseText parses the given text as an XML document and
* returns the newly created Document.
*
- *
+ *
+ * Loading external DTD and entities is disabled (if it is possible) for security reasons.
+ *
* @param text
* the XML text to be parsed
- *
+ *
* @return a newly parsed Document
- *
+ *
* @throws DocumentException
* if the document could not be parsed
*/
public static Document parseText(String text) throws DocumentException {
- Document result = null;
+ SAXReader reader = SAXReader.createDefault();
- SAXReader reader = new SAXReader();
String encoding = getEncoding(text);
InputSource source = new InputSource(new StringReader(text));
source.setEncoding(encoding);
- result = reader.read(source);
+ Document result = reader.read(source);
// if the XML parser doesn't provide a way to retrieve the encoding,
// specify it manually
@@ -322,14 +323,14 @@ public final class DocumentHelper {
* get the first child <a> element, which would be created if it did
* not exist, then the next child <b> and so on until finally a
* <c> element is returned.
- *
+ *
* @param source
* is the Element or Document to start navigating from
* @param path
* is a simple path expression, seperated by '/' which denotes
* the path from the source to the resulting element such as
* a/b/c
- *
+ *
* @return the first Element on the given path which either already existed
* on the path or were created by this method.
*/
@@ -378,24 +379,24 @@ public final class DocumentHelper {
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
- *
+ *
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
- *
+ *
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
- *
+ *
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
- *
+ *
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
- *
+ *
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
- *
+ *
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -407,6 +408,6 @@ public final class DocumentHelper {
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
- *
+ *
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/DocumentType.java b/fine-org-dom4j/src/main/java/org/dom4j/DocumentType.java
index d2c9f3cb2..aaea5eae0 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/DocumentType.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/DocumentType.java
@@ -7,16 +7,17 @@
package org.dom4j;
+import org.dom4j.dtd.Decl;
+
import java.util.List;
/**
- *
* DocumentType defines an XML DOCTYPE declaration.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.10 $
*/
+@SuppressWarnings("unused")
public interface DocumentType extends Node {
/**
* This method is the equivalent to the {@link #getName}method. It is added
@@ -49,7 +50,7 @@ public interface DocumentType extends Node {
*
* @return DOCUMENT ME!
*/
- List getInternalDeclarations();
+ List getInternalDeclarations();
/**
* Sets the list of internal DTD declaration objects, defined in the
@@ -58,7 +59,7 @@ public interface DocumentType extends Node {
* @param declarations
* DOCUMENT ME!
*/
- void setInternalDeclarations(List declarations);
+ void setInternalDeclarations(List declarations);
/**
* Returns a list of internal DTD declaration objects, defined in the
@@ -66,7 +67,7 @@ public interface DocumentType extends Node {
*
* @return DOCUMENT ME!
*/
- List getExternalDeclarations();
+ List getExternalDeclarations();
/**
* Sets the list of internal DTD declaration objects, defined in the
@@ -75,7 +76,7 @@ public interface DocumentType extends Node {
* @param declarations
* DOCUMENT ME!
*/
- void setExternalDeclarations(List declarations);
+ void setExternalDeclarations(List declarations);
}
/*
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/Element.java b/fine-org-dom4j/src/main/java/org/dom4j/Element.java
index 56b446b13..9cf2738c3 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/Element.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/Element.java
@@ -12,839 +12,682 @@ import java.util.List;
import java.util.Map;
/**
- *
* Element interface defines an XML element. An element can have
* declared namespaces, attributes, child nodes and textual content.
- *
- *
*
* Some of this interface is optional. Some implementations may be read-only and
* not support being modified. Some implementations may not support the parent
- * relationship and methods such as {@link #getParent}or {@link#getDocument}.
- *
- *
+ * relationship and methods such as {@link #getParent}or {@link #getDocument}.
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.47 $
*/
+@SuppressWarnings("unused")
public interface Element extends Branch {
- // Name and namespace related methods
- // -------------------------------------------------------------------------
-
- /**
- *
- * Returns the QName of this element which represents the
- * local name, the qualified name and the Namespace.
- *
- *
- * @return the QName associated with this element
- */
- QName getQName();
-
- /**
- *
- * Sets the QName of this element which represents the local
- * name, the qualified name and the Namespace.
- *
- *
- * @param qname
- * is the QName to be associated with this element
- */
- void setQName(QName qname);
-
- /**
- *
- * Returns the Namespace of this element if one exists
- * otherwise Namespace.NO_NAMESPACE is returned.
- *
- *
- * @return the Namespace associated with this element
- */
- Namespace getNamespace();
-
- /**
- *
- * Returns the QName for the given qualified name, using the
- * namespace URI in scope for the given prefix of the qualified name or the
- * default namespace if the qualified name has no prefix.
- *
- *
- * @param qualifiedName
- * DOCUMENT ME!
- *
- * @return the QName for the given qualified name
- */
- QName getQName(String qualifiedName);
-
- /**
- *
- * Returns the Namespace which is mapped to the given prefix
- * or null if it could not be found.
- *
- *
- * @param prefix
- * DOCUMENT ME!
- *
- * @return the Namespace associated with the given prefix
- */
- Namespace getNamespaceForPrefix(String prefix);
-
- /**
- *
- * Returns the Namespace which is mapped to the given URI or
- * null if it could not be found. If there is more than one
- * Namespace mapped to the URI, which of them will be
- * returned is undetermined.
- *
- *
- * @param uri
- * DOCUMENT ME!
- *
- * @return the Namespace associated with the given URI
- */
- Namespace getNamespaceForURI(String uri);
-
- /**
- *
- * Returns the all namespaces which are mapped to the given URI or an empty
- * list if no such namespaces could be found.
- *
- *
- * @param uri
- * DOCUMENT ME!
- *
- * @return the namespaces associated with the given URI
- *
- * @since 1.5
- */
- List getNamespacesForURI(String uri);
-
- /**
- *
- * Returns the namespace prefix of this element if one exists otherwise an
- * empty String is returned.
- *
- *
- * @return the prefix of the Namespace of this element or an
- * empty String
- */
- String getNamespacePrefix();
-
- /**
- *
- * Returns the URI mapped to the namespace of this element if one exists
- * otherwise an empty String is returned.
- *
- *
- * @return the URI for the Namespace of this element or an
- * empty String
- */
- String getNamespaceURI();
-
- /**
- *
- * Returns the fully qualified name of this element. This will be the same
- * as the value returned from {@link #getName}if this element has no
- * namespace attached to this element or an expression of the form
- *
- *
- * getNamespacePrefix() + ":" + getName()
- *
- *
- * will be returned.
- *
- *
- * @return the fully qualified name of the element.
- */
- String getQualifiedName();
-
- /**
- *
- * Returns any additional namespaces declarations for this element other
- * than namespace returned via the {@link #getNamespace()}method. If no
- * additional namespace declarations are present for this element then an
- * empty list will be returned. The list is backed by the element such that
- * changes to the list will be reflected in the element though the reverse
- * is not the case.
- *
- *
- * @return a list of any additional namespace declarations.
- */
- List additionalNamespaces();
-
- /**
- *
- * Returns all the namespaces declared by this element. If no namespaces are
- * declared for this element then an empty list will be returned. The list
- * is backed by the element such that changes to the list will be reflected
- * in the element though the reverse is not the case.
- *
- *
- * @return a list of namespaces declared for this element.
- */
- List declaredNamespaces();
-
- // Builder methods
- // -------------------------------------------------------------------------
-
- /**
- *
- * Adds the attribute value of the given local name. If an attribute already
- * exists for the given name it will be replaced. Attributes with null
- * values are silently ignored. If the value of the attribute is null then
- * this method call will remove any attributes with the given name.
- *
- *
- * @param name
- * is the name of the attribute whose value is to be added or
- * updated
- * @param value
- * is the attribute's value
- *
- * @return this Element instance.
- */
- Element addAttribute(String name, String value);
-
- /**
- *
- * Adds the attribute value of the given fully qualified name. If an
- * attribute already exists for the given name it will be replaced.
- * Attributes with null values are silently ignored. If the value of the
- * attribute is null then this method call will remove any attributes with
- * the given name.
- *
- *
- * @param qName
- * is the fully qualified name of the attribute whose value is to
- * be added or updated
- * @param value
- * is the attribute's value
- *
- * @return this Element instance.
- */
- Element addAttribute(QName qName, String value);
-
- /**
- * Adds a new Comment node with the given text to this
- * element.
- *
- * @param comment
- * is the text for the Comment node.
- *
- * @return this Element instance.
- */
- Element addComment(String comment);
-
- /**
- * Adds a new CDATA node with the given text to this element.
- *
- * @param cdata
- * is the text for the CDATA node.
- *
- * @return this Element instance.
- */
- Element addCDATA(String cdata);
-
- /**
- * Adds a new Entity node with the given name and text to
- * this element and returns a reference to the new node.
- *
- * @param name
- * is the name for the Entity node.
- * @param text
- * is the text for the Entity node.
- *
- * @return this Element instance.
- */
- Element addEntity(String name, String text);
-
- /**
- * Adds a namespace to this element for use by its child content
- *
- * @param prefix
- * is the prefix to use, which should not be null or blank
- * @param uri
- * is the namespace URI
- *
- * @return this Element instance.
- */
- Element addNamespace(String prefix, String uri);
-
- /**
- * Adds a processing instruction for the given target
- *
- * @param target
- * is the target of the processing instruction
- * @param text
- * is the textual data (key/value pairs) of the processing
- * instruction
- *
- * @return this Element instance.
- */
- Element addProcessingInstruction(String target, String text);
-
- /**
- * Adds a processing instruction for the given target
- *
- * @param target
- * is the target of the processing instruction
- * @param data
- * is a Map of the key / value pairs of the processing
- * instruction
- *
- * @return this Element instance.
- */
- Element addProcessingInstruction(String target, Map data);
-
- /**
- * Adds a new Text node with the given text to this element.
- *
- * @param text
- * is the text for the Text node.
- *
- * @return this Element instance.
- */
- Element addText(String text);
-
- // Typesafe modifying methods
- // -------------------------------------------------------------------------
-
- /**
- * Adds the given Attribute to this element. If the given
- * node already has a parent defined then an
- * IllegalAddException will be thrown. Attributes with null
- * values are silently ignored.
- *
- *
- * If the value of the attribute is null then this method call will remove
- * any attributes with the QName of this attribute.
- *
- *
- * @param attribute
- * is the attribute to be added
- */
- void add(Attribute attribute);
-
- /**
- * Adds the given CDATA to this element. If the given node
- * already has a parent defined then an IllegalAddException
- * will be thrown.
- *
- * @param cdata
- * is the CDATA to be added
- */
- void add(CDATA cdata);
-
- /**
- * Adds the given Entity to this element. If the given node
- * already has a parent defined then an IllegalAddException
- * will be thrown.
- *
- * @param entity
- * is the entity to be added
- */
- void add(Entity entity);
-
- /**
- * Adds the given Text to this element. If the given node
- * already has a parent defined then an IllegalAddException
- * will be thrown.
- *
- * @param text
- * is the text to be added
- */
- void add(Text text);
-
- /**
- * Adds the given Namespace to this element. If the given
- * node already has a parent defined then an
- * IllegalAddException will be thrown.
- *
- * @param namespace
- * is the namespace to be added
- */
- void add(Namespace namespace);
-
- /**
- * Removes the given Attribute from this element.
- *
- * @param attribute
- * is the attribute to be removed
- *
- * @return true if the attribute was removed
- */
- boolean remove(Attribute attribute);
-
- /**
- * Removes the given CDATA if the node is an immediate child
- * of this element. If the given node is not an immediate child of this
- * element then the {@link Node#detach()}method should be used instead.
- *
- * @param cdata
- * is the CDATA to be removed
- *
- * @return true if the cdata was removed
- */
- boolean remove(CDATA cdata);
-
- /**
- * Removes the given Entity if the node is an immediate child
- * of this element. If the given node is not an immediate child of this
- * element then the {@link Node#detach()}method should be used instead.
- *
- * @param entity
- * is the entity to be removed
- *
- * @return true if the entity was removed
- */
- boolean remove(Entity entity);
-
- /**
- * Removes the given Namespace if the node is an immediate
- * child of this element. If the given node is not an immediate child of
- * this element then the {@link Node#detach()}method should be used
- * instead.
- *
- * @param namespace
- * is the namespace to be removed
- *
- * @return true if the namespace was removed
- */
- boolean remove(Namespace namespace);
-
- /**
- * Removes the given Text if the node is an immediate child
- * of this element. If the given node is not an immediate child of this
- * element then the {@link Node#detach()}method should be used instead.
- *
- * @param text
- * is the text to be removed
- *
- * @return true if the text was removed
- */
- boolean remove(Text text);
-
- // Text methods
- // -------------------------------------------------------------------------
-
- /**
- * Returns the text value of this element without recursing through child
- * elements. This method iterates through all {@link Text},{@link CDATA}
- * and {@link Entity}nodes that this element contains and appends the text
- * values together.
- *
- * @return the textual content of this Element. Child elements are not
- * navigated. This method does not return null;
- */
- String getText();
-
- /**
- * DOCUMENT ME!
- *
- * @return the trimmed text value where whitespace is trimmed and normalised
- * into single spaces. This method does not return null.
- */
- String getTextTrim();
-
- /**
- * Returns the XPath string-value of this node. The behaviour of this method
- * is defined in the XPath
- * specification . This method returns the string-value of all the
- * contained {@link Text},{@link CDATA},{@link Entity}and {@link
- * Element} nodes all appended together.
- *
- * @return the text from all the child Text and Element nodes appended
- * together.
- */
- String getStringValue();
-
- /**
- * Accesses the data of this element which may implement data typing
- * bindings such as XML Schema or Java Bean bindings or will return the same
- * value as {@link #getText}
- *
- * @return DOCUMENT ME!
- */
- Object getData();
-
- /**
- * Sets the data value of this element if this element supports data binding
- * or calls {@link #setText}if it doesn't
- *
- * @param data
- * DOCUMENT ME!
- */
- void setData(Object data);
-
- // Attribute methods
- // -------------------------------------------------------------------------
-
- /**
- *
- * Returns the {@link Attribute}instances this element contains as a backed
- * {@link List}so that the attributes may be modified directly using the
- * {@link List}interface. The List is backed by the
- * Element so that changes to the list are reflected in the
- * element and vice versa.
- *
- *
- * @return the attributes that this element contains as a List
- */
- List attributes();
-
- /**
- * Sets the attributes that this element contains
- *
- * @param attributes
- * DOCUMENT ME!
- */
- void setAttributes(List attributes);
-
- /**
- * DOCUMENT ME!
- *
- * @return the number of attributes this element contains
- */
- int attributeCount();
-
- /**
- * DOCUMENT ME!
- *
- * @return an iterator over the attributes of this element
- */
- Iterator attributeIterator();
-
- /**
- * Returns the attribute at the specified indexGets the
- *
- * @param index
- * DOCUMENT ME!
- *
- * @return the attribute at the specified index where index >= 0 and
- * index < number of attributes or throws an
- * IndexOutOfBoundsException if the index is not within the
- * allowable range
- */
- Attribute attribute(int index);
-
- /**
- * Returns the attribute with the given name
- *
- * @param name
- * DOCUMENT ME!
- *
- * @return the attribute for the given local name in any namespace. If there
- * are more than one attributes with the given local name in
- * different namespaces then the first one is returned.
- */
- Attribute attribute(String name);
-
- /**
- * DOCUMENT ME!
- *
- * @param qName
- * is the fully qualified name
- *
- * @return the attribute for the given fully qualified name or null if it
- * could not be found.
- */
- Attribute attribute(QName qName);
-
- /**
- *
- * This returns the attribute value for the attribute with the given name
- * and any namespace or null if there is no such attribute or the empty
- * string if the attribute value is empty.
- *
- *
- * @param name
- * is the name of the attribute value to be returnd
- *
- * @return the value of the attribute, null if the attribute does not exist
- * or the empty string
- */
- String attributeValue(String name);
-
- /**
- *
- * This returns the attribute value for the attribute with the given name
- * and any namespace or the default value if there is no such attribute
- * value.
- *
- *
- * @param name
- * is the name of the attribute value to be returnd
- * @param defaultValue
- * is the default value to be returned if the attribute has no
- * value defined.
- *
- * @return the value of the attribute or the defaultValue if the attribute
- * has no value defined.
- */
- String attributeValue(String name, String defaultValue);
-
- /**
- *
- * This returns the attribute value for the attribute with the given fully
- * qualified name or null if there is no such attribute or the empty string
- * if the attribute value is empty.
- *
- *
- * @param qName
- * is the fully qualified name
- *
- * @return the value of the attribute, null if the attribute does not exist
- * or the empty string
- */
- String attributeValue(QName qName);
-
- /**
- *
- * This returns the attribute value for the attribute with the given fully
- * qualified name or the default value if there is no such attribute value.
- *
- *
- * @param qName
- * is the fully qualified name
- * @param defaultValue
- * is the default value to be returned if the attribute has no
- * value defined.
- *
- * @return the value of the attribute or the defaultValue if the attribute
- * has no value defined.
- */
- String attributeValue(QName qName, String defaultValue);
-
- /**
- *
- * Sets the attribute value of the given local name.
- *
- *
- * @param name
- * is the name of the attribute whose value is to be added or
- * updated
- * @param value
- * is the attribute's value
- *
- * @deprecated As of version 0.5. Please use {@link
- * #addAttribute(String,String)} instead. WILL BE REMOVED IN
- * dom4j-1.6 !!
- */
- void setAttributeValue(String name, String value);
-
- /**
- *
- * Sets the attribute value of the given fully qualified name.
- *
- *
- * @param qName
- * is the fully qualified name of the attribute whose value is to
- * be added or updated
- * @param value
- * is the attribute's value
- *
- * @deprecated As of version 0.5. Please use {@link
- * #addAttribute(QName,String)} instead. WILL BE REMOVED IN
- * dom4j-1.6 !!
- */
- void setAttributeValue(QName qName, String value);
-
- // Content methods
- // -------------------------------------------------------------------------
-
- /**
- * Returns the first element for the given local name and any namespace.
- *
- * @param name
- * DOCUMENT ME!
- *
- * @return the first element with the given local name
- */
- Element element(String name);
-
- /**
- * Returns the first element for the given fully qualified name.
- *
- * @param qName
- * is the fully qualified name to search for
- *
- * @return the first element with the given fully qualified name
- */
- Element element(QName qName);
-
- /**
- *
- * Returns the elements contained in this element. If this element does not
- * contain any elements then this method returns an empty list. The list is
- * backed by the element such that changes to the list will be reflected in
- * the element though the reverse is not the case.
- *
- *
- * @return a list of all the elements in this element.
- */
- List elements();
-
- /**
- *
- * Returns the elements contained in this element with the given local name
- * and any namespace. If no elements are found then this method returns an
- * empty list. The list is backed by the element such that changes to the
- * list will be reflected in the element though the reverse is not the case.
- *
- *
- * @param name
- * DOCUMENT ME!
- *
- * @return a list of all the elements in this element for the given local
- * name
- */
- List elements(String name);
-
- /**
- *
- * Returns the elements contained in this element with the given fully
- * qualified name. If no elements are found then this method returns an
- * empty list. The list is backed by the element such that changes to the
- * list will be reflected in the element though the reverse is not the case.
- *
- *
- * @param qName
- * is the fully qualified name to search for
- *
- * @return a list of all the elements in this element for the given fully
- * qualified name.
- */
- List elements(QName qName);
-
- /**
- * Returns an iterator over all this elements child elements.
- *
- * @return an iterator over the contained elements
- */
- Iterator elementIterator();
-
- /**
- * Returns an iterator over the elements contained in this element which
- * match the given local name and any namespace.
- *
- * @param name
- * DOCUMENT ME!
- *
- * @return an iterator over the contained elements matching the given local
- * name
- */
- Iterator elementIterator(String name);
-
- /**
- * Returns an iterator over the elements contained in this element which
- * match the given fully qualified name.
- *
- * @param qName
- * is the fully qualified name to search for
- *
- * @return an iterator over the contained elements matching the given fully
- * qualified name
- */
- Iterator elementIterator(QName qName);
-
- // Helper methods
- // -------------------------------------------------------------------------
-
- /**
- * DOCUMENT ME!
- *
- * @return true if this element is the root element of a document and this
- * element supports the parent relationship else false.
- */
- boolean isRootElement();
-
- /**
- *
- * Returns true if this Element has mixed content. Mixed
- * content means that an element contains both textual data and child
- * elements.
- *
- *
- * @return true if this element contains mixed content.
- */
- boolean hasMixedContent();
-
- /**
- *
- * Returns true if this Element has text only content.
- *
- *
- * @return true if this element is empty or only contains text content.
- */
- boolean isTextOnly();
-
- /**
- * Appends the attributes of the given element to me. This method behaves
- * like the {@link java.util.Collection#addAll(java.util.Collection)}
- * method.
- *
- * @param element
- * is the element whose attributes will be added to me.
- */
- void appendAttributes(Element element);
-
- /**
- *
- * Creates a deep copy of this element The new element is detached from its
- * parent, and getParent() on the clone will return null.
- *
- *
- * @return a new deep copy Element
- */
- Element createCopy();
-
- /**
- *
- * Creates a deep copy of this element with the given local name The new
- * element is detached from its parent, and getParent() on the clone will
- * return null.
- *
- *
- * @param name
- * DOCUMENT ME!
- *
- * @return a new deep copy Element
- */
- Element createCopy(String name);
-
- /**
- *
- * Creates a deep copy of this element with the given fully qualified name.
- * The new element is detached from its parent, and getParent() on the clone
- * will return null.
- *
- *
- * @param qName
- * DOCUMENT ME!
- *
- * @return a new deep copy Element
- */
- Element createCopy(QName qName);
-
- String elementText(String name);
-
- String elementText(QName qname);
-
- String elementTextTrim(String name);
-
- String elementTextTrim(QName qname);
-
- /**
- * Returns a node at the given index suitable for an XPath result set. This
- * means the resulting Node will either be null or it will support the
- * parent relationship.
- *
- * @param index
- * DOCUMENT ME!
- *
- * @return the Node for the given index which will support the parent
- * relationship or null if there is not a node at the given index.
- */
- Node getXPathResult(int index);
+ // Name and namespace related methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Returns the QName of this element which represents the
+ * local name, the qualified name and the Namespace.
+ *
+ * @return the QName associated with this element
+ */
+ QName getQName();
+
+ /**
+ * Sets the QName of this element which represents the local
+ * name, the qualified name and the Namespace.
+ *
+ * @param qname is the QName to be associated with this element
+ */
+ void setQName(QName qname);
+
+ /**
+ * Returns the Namespace of this element if one exists
+ * otherwise Namespace.NO_NAMESPACE is returned.
+ *
+ * @return the Namespace associated with this element
+ */
+ Namespace getNamespace();
+
+ /**
+ * Returns the QName for the given qualified name, using the
+ * namespace URI in scope for the given prefix of the qualified name or the
+ * default namespace if the qualified name has no prefix.
+ *
+ * @param qualifiedName DOCUMENT ME!
+ * @return the QName for the given qualified name
+ */
+ QName getQName(String qualifiedName);
+
+ /**
+ * Returns the Namespace which is mapped to the given prefix
+ * or null if it could not be found.
+ *
+ * @param prefix DOCUMENT ME!
+ * @return the Namespace associated with the given prefix
+ */
+ Namespace getNamespaceForPrefix(String prefix);
+
+ /**
+ * Returns the Namespace which is mapped to the given URI or
+ * null if it could not be found. If there is more than one
+ * Namespace mapped to the URI, which of them will be
+ * returned is undetermined.
+ *
+ * @param uri DOCUMENT ME!
+ * @return the Namespace associated with the given URI
+ */
+ Namespace getNamespaceForURI(String uri);
+
+ /**
+ * Returns the all namespaces which are mapped to the given URI or an empty
+ * list if no such namespaces could be found.
+ *
+ * @param uri DOCUMENT ME!
+ * @return the namespaces associated with the given URI
+ * @since 1.5
+ */
+ List getNamespacesForURI(String uri);
+
+ /**
+ * Returns the namespace prefix of this element if one exists otherwise an
+ * empty String is returned.
+ *
+ * @return the prefix of the Namespace of this element or an
+ * empty String
+ */
+ String getNamespacePrefix();
+
+ /**
+ * Returns the URI mapped to the namespace of this element if one exists
+ * otherwise an empty String is returned.
+ *
+ * @return the URI for the Namespace of this element or an
+ * empty String
+ */
+ String getNamespaceURI();
+
+ /**
+ * Returns the fully qualified name of this element. This will be the same
+ * as the value returned from {@link #getName}if this element has no
+ * namespace attached to this element or an expression of the form
+ *
+ * getNamespacePrefix() + ":" + getName()
+ *
+ * will be returned.
+ *
+ * @return the fully qualified name of the element.
+ */
+ String getQualifiedName();
+
+ /**
+ * Returns any additional namespaces declarations for this element other
+ * than namespace returned via the {@link #getNamespace()}method. If no
+ * additional namespace declarations are present for this element then an
+ * empty list will be returned. The list is backed by the element such that
+ * changes to the list will be reflected in the element though the reverse
+ * is not the case.
+ *
+ * @return a list of any additional namespace declarations.
+ */
+ List additionalNamespaces();
+
+ /**
+ * Returns all the namespaces declared by this element. If no namespaces are
+ * declared for this element then an empty list will be returned. The list
+ * is backed by the element such that changes to the list will be reflected
+ * in the element though the reverse is not the case.
+ *
+ * @return a list of namespaces declared for this element.
+ */
+ List declaredNamespaces();
+
+ // Builder methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Adds the attribute value of the given local name. If an attribute already
+ * exists for the given name it will be replaced. Attributes with null
+ * values are silently ignored. If the value of the attribute is null then
+ * this method call will remove any attributes with the given name.
+ *
+ * @param name is the name of the attribute whose value is to be added or
+ * updated
+ * @param value is the attribute's value
+ * @return this Element instance.
+ */
+ Element addAttribute(String name, String value);
+
+ /**
+ * Adds the attribute value of the given fully qualified name. If an
+ * attribute already exists for the given name it will be replaced.
+ * Attributes with null values are silently ignored. If the value of the
+ * attribute is null then this method call will remove any attributes with
+ * the given name.
+ *
+ * @param qName is the fully qualified name of the attribute whose value is to
+ * be added or updated
+ * @param value is the attribute's value
+ * @return this Element instance.
+ */
+ Element addAttribute(QName qName, String value);
+
+ /**
+ * Adds a new Comment node with the given text to this
+ * element.
+ *
+ * @param comment is the text for the Comment node.
+ * @return this Element instance.
+ */
+ Element addComment(String comment);
+
+ /**
+ * Adds a new CDATA node with the given text to this element.
+ *
+ * @param cdata is the text for the CDATA node.
+ * @return this Element instance.
+ */
+ Element addCDATA(String cdata);
+
+ /**
+ * Adds a new Entity node with the given name and text to
+ * this element and returns a reference to the new node.
+ *
+ * @param name is the name for the Entity node.
+ * @param text is the text for the Entity node.
+ * @return this Element instance.
+ */
+ Element addEntity(String name, String text);
+
+ /**
+ * Adds a namespace to this element for use by its child content
+ *
+ * @param prefix is the prefix to use, which should not be null or blank
+ * @param uri is the namespace URI
+ * @return this Element instance.
+ */
+ Element addNamespace(String prefix, String uri);
+
+ /**
+ * Adds a processing instruction for the given target
+ *
+ * @param target is the target of the processing instruction
+ * @param text is the textual data (key/value pairs) of the processing
+ * instruction
+ * @return this Element instance.
+ */
+ Element addProcessingInstruction(String target, String text);
+
+ /**
+ * Adds a processing instruction for the given target
+ *
+ * @param target is the target of the processing instruction
+ * @param data is a Map of the key / value pairs of the processing
+ * instruction
+ * @return this Element instance.
+ */
+ Element addProcessingInstruction(String target, Map data);
+
+ /**
+ * Adds a new Text node with the given text to this element.
+ *
+ * @param text is the text for the Text node.
+ * @return this Element instance.
+ */
+ Element addText(String text);
+
+ // Typesafe modifying methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Adds the given Attribute to this element. If the given
+ * node already has a parent defined then an
+ * IllegalAddException will be thrown. Attributes with null
+ * values are silently ignored.
+ *
+ * If the value of the attribute is null then this method call will remove
+ * any attributes with the QName of this attribute.
+ *
+ * @param attribute is the attribute to be added
+ */
+ void add(Attribute attribute);
+
+ /**
+ * Adds the given CDATA to this element. If the given node
+ * already has a parent defined then an IllegalAddException
+ * will be thrown.
+ *
+ * @param cdata is the CDATA to be added
+ */
+ void add(CDATA cdata);
+
+ /**
+ * Adds the given Entity to this element. If the given node
+ * already has a parent defined then an IllegalAddException
+ * will be thrown.
+ *
+ * @param entity is the entity to be added
+ */
+ void add(Entity entity);
+
+ /**
+ * Adds the given Text to this element. If the given node
+ * already has a parent defined then an IllegalAddException
+ * will be thrown.
+ *
+ * @param text is the text to be added
+ */
+ void add(Text text);
+
+ /**
+ * Adds the given Namespace to this element. If the given
+ * node already has a parent defined then an
+ * IllegalAddException will be thrown.
+ *
+ * @param namespace is the namespace to be added
+ */
+ void add(Namespace namespace);
+
+ /**
+ * Removes the given Attribute from this element.
+ *
+ * @param attribute is the attribute to be removed
+ * @return true if the attribute was removed
+ */
+ boolean remove(Attribute attribute);
+
+ /**
+ * Removes the given CDATA if the node is an immediate child
+ * of this element. If the given node is not an immediate child of this
+ * element then the {@link Node#detach()}method should be used instead.
+ *
+ * @param cdata is the CDATA to be removed
+ * @return true if the cdata was removed
+ */
+ boolean remove(CDATA cdata);
+
+ /**
+ * Removes the given Entity if the node is an immediate child
+ * of this element. If the given node is not an immediate child of this
+ * element then the {@link Node#detach()}method should be used instead.
+ *
+ * @param entity is the entity to be removed
+ * @return true if the entity was removed
+ */
+ boolean remove(Entity entity);
+
+ /**
+ * Removes the given Namespace if the node is an immediate
+ * child of this element. If the given node is not an immediate child of
+ * this element then the {@link Node#detach()}method should be used
+ * instead.
+ *
+ * @param namespace is the namespace to be removed
+ * @return true if the namespace was removed
+ */
+ boolean remove(Namespace namespace);
+
+ /**
+ * Removes the given Text if the node is an immediate child
+ * of this element. If the given node is not an immediate child of this
+ * element then the {@link Node#detach()}method should be used instead.
+ *
+ * @param text is the text to be removed
+ * @return true if the text was removed
+ */
+ boolean remove(Text text);
+
+ // Text methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Returns the text value of this element without recursing through child
+ * elements. This method iterates through all {@link Text},{@link CDATA}
+ * and {@link Entity}nodes that this element contains and appends the text
+ * values together.
+ *
+ * @return the textual content of this Element. Child elements are not
+ * navigated. This method does not return null;
+ */
+ String getText();
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @return the trimmed text value where whitespace is trimmed and normalised
+ * into single spaces. This method does not return null.
+ */
+ String getTextTrim();
+
+ /**
+ * Returns the XPath string-value of this node. The behaviour of this method
+ * is defined in the XPath
+ * specification . This method returns the string-value of all the
+ * contained {@link Text},{@link CDATA},{@link Entity}and {@link
+ * Element} nodes all appended together.
+ *
+ * @return the text from all the child Text and Element nodes appended
+ * together.
+ */
+ String getStringValue();
+
+ /**
+ * Accesses the data of this element which may implement data typing
+ * bindings such as XML Schema or Java Bean bindings or will return the same
+ * value as {@link #getText}
+ *
+ * @return DOCUMENT ME!
+ */
+ Object getData();
+
+ /**
+ * Sets the data value of this element if this element supports data binding
+ * or calls {@link #setText}if it doesn't
+ *
+ * @param data DOCUMENT ME!
+ */
+ void setData(Object data);
+
+ // Attribute methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Returns the {@link Attribute}instances this element contains as a backed
+ * {@link List}so that the attributes may be modified directly using the
+ * {@link List}interface. The List is backed by the
+ * Element so that changes to the list are reflected in the
+ * element and vice versa.
+ *
+ * @return the attributes that this element contains as a List
+ */
+ List attributes();
+
+ /**
+ * Sets the attributes that this element contains
+ *
+ * @param attributes DOCUMENT ME!
+ */
+ void setAttributes(List attributes);
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @return the number of attributes this element contains
+ */
+ int attributeCount();
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @return an iterator over the attributes of this element
+ */
+ Iterator attributeIterator();
+
+ /**
+ * Returns the attribute at the specified indexGets the
+ *
+ * @param index DOCUMENT ME!
+ * @return the attribute at the specified index where index >= 0 and
+ * index < number of attributes or throws an
+ * IndexOutOfBoundsException if the index is not within the
+ * allowable range
+ */
+ Attribute attribute(int index);
+
+ /**
+ * Returns the attribute with the given name
+ *
+ * @param name DOCUMENT ME!
+ * @return the attribute for the given local name in any namespace. If there
+ * are more than one attributes with the given local name in
+ * different namespaces then the first one is returned.
+ */
+ Attribute attribute(String name);
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param qName is the fully qualified name
+ * @return the attribute for the given fully qualified name or null if it
+ * could not be found.
+ */
+ Attribute attribute(QName qName);
+
+ /**
+ * This returns the attribute value for the attribute with the given name
+ * and any namespace or null if there is no such attribute or the empty
+ * string if the attribute value is empty.
+ *
+ * @param name is the name of the attribute value to be returned
+ * @return the value of the attribute, null if the attribute does not exist
+ * or the empty string
+ */
+ String attributeValue(String name);
+
+ /**
+ * This returns the attribute value for the attribute with the given name
+ * and any namespace or the default value if there is no such attribute
+ * value.
+ *
+ * @param name is the name of the attribute value to be returned
+ * @param defaultValue is the default value to be returned if the attribute has no
+ * value defined.
+ * @return the value of the attribute or the defaultValue if the attribute
+ * has no value defined.
+ */
+ String attributeValue(String name, String defaultValue);
+
+ /**
+ * This returns the attribute value for the attribute with the given fully
+ * qualified name or null if there is no such attribute or the empty string
+ * if the attribute value is empty.
+ *
+ * @param qName is the fully qualified name
+ * @return the value of the attribute, null if the attribute does not exist
+ * or the empty string
+ */
+ String attributeValue(QName qName);
+
+ /**
+ * This returns the attribute value for the attribute with the given fully
+ * qualified name or the default value if there is no such attribute value.
+ *
+ * @param qName is the fully qualified name
+ * @param defaultValue is the default value to be returned if the attribute has no
+ * value defined.
+ * @return the value of the attribute or the defaultValue if the attribute
+ * has no value defined.
+ */
+ String attributeValue(QName qName, String defaultValue);
+
+ /**
+ * Sets the attribute value of the given local name.
+ *
+ * @param name is the name of the attribute whose value is to be added or
+ * updated
+ * @param value is the attribute's value
+ * @deprecated As of version 0.5. Please use {@link
+ * #addAttribute(String, String)} instead. WILL BE REMOVED IN
+ * dom4j-1.6 !!
+ */
+ void setAttributeValue(String name, String value);
+
+ /**
+ * Sets the attribute value of the given fully qualified name.
+ *
+ * @param qName is the fully qualified name of the attribute whose value is to
+ * be added or updated
+ * @param value is the attribute's value
+ * @deprecated As of version 0.5. Please use {@link
+ * #addAttribute(QName, String)} instead. WILL BE REMOVED IN
+ * dom4j-1.6 !!
+ */
+ void setAttributeValue(QName qName, String value);
+
+ // Content methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * Returns the first element for the given local name and any namespace.
+ *
+ * @param name DOCUMENT ME!
+ * @return the first element with the given local name
+ */
+ Element element(String name);
+
+ /**
+ * Returns the first element for the given fully qualified name.
+ *
+ * @param qName is the fully qualified name to search for
+ * @return the first element with the given fully qualified name
+ */
+ Element element(QName qName);
+
+ /**
+ * Returns the elements contained in this element. If this element does not
+ * contain any elements then this method returns an empty list. The list is
+ * backed by the element such that changes to the list will be reflected in
+ * the element though the reverse is not the case.
+ *
+ * @return a list of all the elements in this element.
+ */
+ List elements();
+
+ /**
+ * Returns the elements contained in this element with the given local name
+ * and any namespace. If no elements are found then this method returns an
+ * empty list. The list is backed by the element such that changes to the
+ * list will be reflected in the element though the reverse is not the case.
+ *
+ * @param name DOCUMENT ME!
+ * @return a list of all the elements in this element for the given local
+ * name
+ */
+ List elements(String name);
+
+ /**
+ * Returns the elements contained in this element with the given fully
+ * qualified name. If no elements are found then this method returns an
+ * empty list. The list is backed by the element such that changes to the
+ * list will be reflected in the element though the reverse is not the case.
+ *
+ * @param qName is the fully qualified name to search for
+ * @return a list of all the elements in this element for the given fully
+ * qualified name.
+ */
+ List elements(QName qName);
+
+ /**
+ * Returns an iterator over all this elements child elements.
+ *
+ * @return an iterator over the contained elements
+ */
+ Iterator elementIterator();
+
+ /**
+ * Returns an iterator over the elements contained in this element which
+ * match the given local name and any namespace.
+ *
+ * @param name DOCUMENT ME!
+ * @return an iterator over the contained elements matching the given local
+ * name
+ */
+ Iterator elementIterator(String name);
+
+ /**
+ * Returns an iterator over the elements contained in this element which
+ * match the given fully qualified name.
+ *
+ * @param qName is the fully qualified name to search for
+ * @return an iterator over the contained elements matching the given fully
+ * qualified name
+ */
+ Iterator elementIterator(QName qName);
+
+ // Helper methods
+ // -------------------------------------------------------------------------
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @return true if this element is the root element of a document and this
+ * element supports the parent relationship else false.
+ */
+ boolean isRootElement();
+
+ /**
+ * Returns true if this Element has mixed content. Mixed
+ * content means that an element contains both textual data and child
+ * elements.
+ *
+ * @return true if this element contains mixed content.
+ */
+ boolean hasMixedContent();
+
+ /**
+ * Returns true if this Element has text only content.
+ *
+ * @return true if this element is empty or only contains text content.
+ */
+ boolean isTextOnly();
+
+ /**
+ * Appends the attributes of the given element to me. This method behaves
+ * like the {@link java.util.Collection#addAll(java.util.Collection)}
+ * method.
+ *
+ * @param element is the element whose attributes will be added to me.
+ */
+ void appendAttributes(Element element);
+
+ /**
+ * Creates a deep copy of this element The new element is detached from its
+ * parent, and getParent() on the clone will return null.
+ *
+ * @return a new deep copy Element
+ */
+ Element createCopy();
+
+ /**
+ * Creates a deep copy of this element with the given local name The new
+ * element is detached from its parent, and getParent() on the clone will
+ * return null.
+ *
+ * @param name DOCUMENT ME!
+ * @return a new deep copy Element
+ */
+ Element createCopy(String name);
+
+ /**
+ * Creates a deep copy of this element with the given fully qualified name.
+ * The new element is detached from its parent, and getParent() on the clone
+ * will return null.
+ *
+ * @param qName DOCUMENT ME!
+ * @return a new deep copy Element
+ */
+ Element createCopy(QName qName);
+
+ String elementText(String name);
+
+ String elementText(QName qname);
+
+ String elementTextTrim(String name);
+
+ String elementTextTrim(QName qname);
+
+ /**
+ * Returns a node at the given index suitable for an XPath result set. This
+ * means the resulting Node will either be null or it will support the
+ * parent relationship.
+ *
+ * @param index DOCUMENT ME!
+ * @return the Node for the given index which will support the parent
+ * relationship or null if there is not a node at the given index.
+ */
+ Node getXPathResult(int index);
}
/*
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/ElementHandler.java b/fine-org-dom4j/src/main/java/org/dom4j/ElementHandler.java
index a03bf85c0..f195891fc 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/ElementHandler.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/ElementHandler.java
@@ -8,16 +8,15 @@
package org.dom4j;
/**
- *
* ElementHandler interface defines a handler of
* Element objects. It is used primarily in event based
* processing models such as for processing large XML documents as they are
* being parsed rather than waiting until the whole document is parsed.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.8 $
*/
+@SuppressWarnings("unused")
public interface ElementHandler {
/**
* Called by an event based processor when an elements openning tag is
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/ElementPath.java b/fine-org-dom4j/src/main/java/org/dom4j/ElementPath.java
index 2d8784c7f..8ddfdf6cc 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/ElementPath.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/ElementPath.java
@@ -13,8 +13,9 @@ package org.dom4j;
* primary use is to retrieve the current {@link Element}being processed.
*
* @author Dave White
- * @version $Revision$
+ * @version $Revision: 1.6 $
*/
+@SuppressWarnings("unused")
public interface ElementPath {
/**
* DOCUMENT ME!
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/Entity.java b/fine-org-dom4j/src/main/java/org/dom4j/Entity.java
index 7c851691e..e79a8e70e 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/Entity.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/Entity.java
@@ -8,13 +8,12 @@
package org.dom4j;
/**
- *
* Namespace is a Flyweight Namespace that can be shared amongst
* nodes.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.22 $
*/
public class Namespace extends AbstractNode {
/** Cache of Namespace instances */
@@ -51,6 +49,10 @@ public class Namespace extends AbstractNode {
public Namespace(String prefix, String uri) {
this.prefix = (prefix != null) ? prefix : "";
this.uri = (uri != null) ? uri : "";
+
+ if (!this.prefix.isEmpty()) {
+ QName.validateNCName(this.prefix);
+ }
}
/**
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/Node.java b/fine-org-dom4j/src/main/java/org/dom4j/Node.java
index fd11396cf..1cec5a3da 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/Node.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/Node.java
@@ -12,26 +12,21 @@ import java.io.Writer;
import java.util.List;
/**
- *
* Node defines the polymorphic behavior for all XML nodes in a
* dom4j tree.
- *
- *
- *
+ *
* A node can be output as its XML format, can be detached from its position in
* a document and can have XPath expressions evaluated on itself.
- *
- *
- *
+ *
* A node may optionally support the parent relationship and may be read only.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.31 $
*
* @see #supportsParent
* @see #isReadOnly
*/
+@SuppressWarnings("unused")
public interface Node extends Cloneable {
// W3C DOM complient node type codes
@@ -381,7 +376,7 @@ public interface Node extends Cloneable {
* @return the list of Node or String
* instances depending on the XPath expression
*/
- List selectNodes(String xpathExpression);
+ List selectNodes(String xpathExpression);
/**
*
@@ -417,7 +412,7 @@ public interface Node extends Cloneable {
* @return the list of Node instances sorted by the
* comparisonXPathExpression
*/
- List selectNodes(String xpathExpression, String comparisonXPathExpression);
+ List selectNodes(String xpathExpression, String comparisonXPathExpression);
/**
*
@@ -438,7 +433,7 @@ public interface Node extends Cloneable {
* @return the list of Node instances sorted by the
* comparisonXPathExpression
*/
- List selectNodes(String xpathExpression, String comparisonXPathExpression,
+ List selectNodes(String xpathExpression, String comparisonXPathExpression,
boolean removeDuplicates);
/**
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/NodeFilter.java b/fine-org-dom4j/src/main/java/org/dom4j/NodeFilter.java
index 936143323..a5091b9f7 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/NodeFilter.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/NodeFilter.java
@@ -8,15 +8,14 @@
package org.dom4j;
/**
- *
* NodeFilter defines the behavior for a filter or predicate
* which acts on a DOM4J Node. Instances can be generated from an {@link
* DocumentFactory}.
- *
* ProcessingInstruction defines an XML processing instruction.
* The {@link Node#getName}method will return the target of the PI and the
* {@link Node#getText}method will return the data from all of the
* instructions.
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.10 $
*/
+@SuppressWarnings("unused")
public interface ProcessingInstruction extends Node {
/**
* This method is the equivalent to the {@link #getName}method. It is added
@@ -63,11 +62,11 @@ public interface ProcessingInstruction extends Node {
*
* @return the values for this processing instruction as a Map
*/
- Map getValues();
+ Map getValues();
void setValue(String name, String value);
- void setValues(Map data);
+ void setValues(Map data);
boolean removeValue(String name);
}
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/QName.java b/fine-org-dom4j/src/main/java/org/dom4j/QName.java
index 955c0d386..e9b2170e9 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/QName.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/QName.java
@@ -11,40 +11,114 @@ import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
+import java.util.regex.Pattern;
import org.dom4j.tree.QNameCache;
import org.dom4j.util.SingletonStrategy;
/**
- *
* QName represents a qualified name value of an XML element or
* attribute. It consists of a local name and a {@link Namespace}instance. This
* object is immutable.
- *
- *
+ *
* @author James Strachan
+ * @author Filip Jirsák
*/
public class QName implements Serializable {
/** The Singleton instance */
- private static SingletonStrategy singleton = null;
+ private static SingletonStrategy singleton = null;
+
+ /**
+ * {@code NameStartChar} without colon.
+ *
+ *
* Visitor is used to implement the Visitor
* pattern in DOM4J. An object of this interface can be passed to a
* Node which will then call its typesafe methods. Please refer
* to the Gang of Four book of Design Patterns for more details on the
* Visitor pattern.
- *
- *
- *
+ *
* This site
* has further discussion on design patterns and links to the GOF book. This link describes the
* Visitor pattern in detail.
- *
* VisitorSupport is an abstract base class which is useful for
* implementation inheritence or when using anonymous inner classes to create
* simple Visitor implementations.
- *
- * getText will return the textual version of the XPath
- * expression.
- *
- *
- * @return the textual format of the XPath expression.
- */
- String getText();
+ /**
+ * getText will return the textual version of the XPath
+ * expression.
+ *
+ * @return the textual format of the XPath expression.
+ */
+ String getText();
- /**
- *
- * matches returns true if the given node matches the XPath
- * expression. To be more precise when evaluating this XPath expression on
- * the given node the result set must include the node.
- *
- *
- * @param node
- * DOCUMENT ME!
- *
- * @return true if the given node matches this XPath expression
- */
- boolean matches(Node node);
+ /**
+ * matches returns true if the given node matches the XPath
+ * expression. To be more precise when evaluating this XPath expression on
+ * the given node the result set must include the node.
+ *
+ * @param node DOCUMENT ME!
+ * @return true if the given node matches this XPath expression
+ */
+ boolean matches(Node node);
- /**
- *
- * evaluate evaluates an XPath expression and returns the
- * result as an {@link Object}. The object returned can either be a {@link
- * List} of {@link Node}instances, a {@link Node}instance, a {@link
- * String} or a {@link Number}instance depending on the XPath expression.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return the value of the XPath expression as a {@link List}of {@link
- * Node} instances, a {@link Node}instance, a {@link String}or a
- * {@link Number}instance depending on the XPath expression.
- */
- Object evaluate(Object context);
+ /**
+ * evaluate evaluates an XPath expression and returns the
+ * result as an {@link Object}. The object returned can either be a {@link
+ * List} of {@link Node}instances, a {@link Node}instance, a {@link
+ * String} or a {@link Number}instance depending on the XPath expression.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return the value of the XPath expression as a {@link List}of {@link
+ * Node} instances, a {@link Node}instance, a {@link String}or a
+ * {@link Number}instance depending on the XPath expression.
+ */
+ Object evaluate(Object context);
- /**
- *
- * selectObject evaluates an XPath expression and returns the
- * result as an {@link Object}. The object returned can either be a {@link
- * List} of {@link Node}instances, a {@link Node}instance, a {@link
- * String} or a {@link Number}instance depending on the XPath expression.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return the value of the XPath expression as a {@link List}of {@link
- * Node} instances, a {@link Node}instance, a {@link String}or a
- * {@link Number}instance depending on the XPath expression.
- *
- * @deprecated please use evaluate(Object) instead. WILL BE REMOVED IN
- * dom4j-1.6 !!
- */
- Object selectObject(Object context);
+ /**
+ * selectObject evaluates an XPath expression and returns the
+ * result as an {@link Object}. The object returned can either be a {@link
+ * List} of {@link Node}instances, a {@link Node}instance, a {@link
+ * String} or a {@link Number}instance depending on the XPath expression.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return the value of the XPath expression as a {@link List}of {@link
+ * Node} instances, a {@link Node}instance, a {@link String}or a
+ * {@link Number}instance depending on the XPath expression.
+ * @deprecated please use evaluate(Object) instead. WILL BE REMOVED IN
+ * dom4j-1.6 !!
+ */
+ Object selectObject(Object context);
- /**
- *
- * selectNodes performs this XPath expression on the given
- * {@link Node}or {@link List}of {@link Node}s instances appending all
- * the results together into a single list.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return the results of all the XPath evaluations as a single list
- */
- List selectNodes(Object context);
+ /**
+ * selectNodes performs this XPath expression on the given
+ * {@link Node}or {@link List}of {@link Node}s instances appending all
+ * the results together into a single list.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return the results of all the XPath evaluations as a single list
+ */
+ List selectNodes(Object context);
- /**
- *
- * selectNodes evaluates the XPath expression on the given
- * {@link Node}or {@link List}of {@link Node}s and returns the result as
- * a List of Node s sorted by the sort XPath
- * expression.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- * @param sortXPath
- * is the XPath expression to sort by
- *
- * @return a list of Node instances
- */
- List selectNodes(Object context, XPath sortXPath);
+ /**
+ * selectNodes evaluates the XPath expression on the given
+ * {@link Node}or {@link List}of {@link Node}s and returns the result as
+ * a List of Node s sorted by the sort XPath
+ * expression.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @param sortXPath is the XPath expression to sort by
+ * @return a list of Node instances
+ */
+ List selectNodes(Object context, XPath sortXPath);
- /**
- *
- * selectNodes evaluates the XPath expression on the given
- * {@link Node}or {@link List}of {@link Node}s and returns the result as
- * a List of Node s sorted by the sort XPath
- * expression.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- * @param sortXPath
- * is the XPath expression to sort by
- * @param distinct
- * specifies whether or not duplicate values of the sort
- * expression are allowed. If this parameter is true then only
- * distinct sort expressions values are included in the result
- *
- * @return a list of Node instances
- */
- List selectNodes(Object context, XPath sortXPath, boolean distinct);
+ /**
+ * selectNodes evaluates the XPath expression on the given
+ * {@link Node}or {@link List}of {@link Node}s and returns the result as
+ * a List of Node s sorted by the sort XPath
+ * expression.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @param sortXPath is the XPath expression to sort by
+ * @param distinct specifies whether or not duplicate values of the sort
+ * expression are allowed. If this parameter is true then only
+ * distinct sort expressions values are included in the result
+ * @return a list of Node instances
+ */
+ List selectNodes(Object context, XPath sortXPath, boolean distinct);
- /**
- *
- * selectSingleNode evaluates this XPath expression on the
- * given {@link Node}or {@link List}of {@link Node}s and returns the
- * result as a single Node instance.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return a single matching Node instance
- */
- Node selectSingleNode(Object context);
+ /**
+ * selectSingleNode evaluates this XPath expression on the
+ * given {@link Node}or {@link List}of {@link Node}s and returns the
+ * result as a single Node instance.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return a single matching Node instance
+ */
+ Node selectSingleNode(Object context);
- /**
- *
- * valueOf evaluates this XPath expression and returns the
- * textual representation of the results using the XPath string() function.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return the string representation of the results of the XPath expression
- */
- String valueOf(Object context);
+ /**
+ * valueOf evaluates this XPath expression and returns the
+ * textual representation of the results using the XPath string() function.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return the string representation of the results of the XPath expression
+ */
+ String valueOf(Object context);
- /**
- *
- * numberValueOf evaluates an XPath expression and returns
- * the numeric value of the XPath expression if the XPath expression results
- * is a number, or null if the result is not a number.
- *
- *
- * @param context
- * is either a node or a list of nodes on which to evalute the
- * XPath
- *
- * @return the numeric result of the XPath expression or null if the result
- * is not a number.
- */
- Number numberValueOf(Object context);
+ /**
+ * numberValueOf evaluates an XPath expression and returns
+ * the numeric value of the XPath expression if the XPath expression results
+ * is a number, or null if the result is not a number.
+ *
+ * @param context is either a node or a list of nodes on which to evalute the
+ * XPath
+ * @return the numeric result of the XPath expression or null if the result
+ * is not a number.
+ */
+ Number numberValueOf(Object context);
- /**
- * Retrieve a boolean-value interpretation of this XPath expression when
- * evaluated against a given context.
- *
- *
- * The boolean-value of the expression is determined per the
- * boolean(..) core function as defined in the XPath
- * specification. This means that an expression that selects zero nodes will
- * return false, while an expression that selects
- * one-or-more nodes will return true.
- *
- *
- * @param context
- * The node, nodeset or Context object for evaluation. This value
- * can be null
- *
- * @return The boolean-value interpretation of this expression.
- *
- * @since 1.5
- */
- boolean booleanValueOf(Object context);
+ /**
+ * Retrieve a boolean-value interpretation of this XPath expression when
+ * evaluated against a given context.
+ *
+ * The boolean-value of the expression is determined per the
+ * boolean(..) core function as defined in the XPath
+ * specification. This means that an expression that selects zero nodes will
+ * return false, while an expression that selects
+ * one-or-more nodes will return true.
+ *
+ * @param context The node, nodeset or Context object for evaluation. This value
+ * can be null
+ * @return The boolean-value interpretation of this expression.
+ * @since 1.5
+ */
+ boolean booleanValueOf(Object context);
- /**
- *
- * sort sorts the given List of Nodes using this XPath
- * expression as a {@link java.util.Comparator}.
- *
- *
- * @param list
- * is the list of Nodes to sort
- */
- void sort(List list);
+ /**
+ * sort sorts the given List of Nodes using this XPath
+ * expression as a {@link java.util.Comparator}.
+ *
+ * @param list is the list of Nodes to sort
+ */
+ void sort(List list);
- /**
- *
- * sort sorts the given List of Nodes using this XPath
- * expression as a {@link java.util.Comparator}and optionally removing
- * duplicates.
- *
- *
- * @param list
- * is the list of Nodes to sort
- * @param distinct
- * if true then duplicate values (using the sortXPath for
- * comparisions) will be removed from the List
- */
- void sort(List list, boolean distinct);
+ /**
+ * sort sorts the given List of Nodes using this XPath
+ * expression as a {@link java.util.Comparator}and optionally removing
+ * duplicates.
+ *
+ * @param list is the list of Nodes to sort
+ * @param distinct if true then duplicate values (using the sortXPath for
+ * comparisions) will be removed from the List
+ */
+ void sort(List list, boolean distinct);
- /**
- * DOCUMENT ME!
- *
- * @return the current function context
- */
- FunctionContext getFunctionContext();
+ /**
+ * DOCUMENT ME!
+ *
+ * @return the current function context
+ */
+ FunctionContext getFunctionContext();
- /**
- * Sets the function context to be used when evaluating XPath expressions
- *
- * @param functionContext
- * DOCUMENT ME!
- */
- void setFunctionContext(FunctionContext functionContext);
+ /**
+ * Sets the function context to be used when evaluating XPath expressions
+ *
+ * @param functionContext DOCUMENT ME!
+ */
+ void setFunctionContext(FunctionContext functionContext);
- /**
- * DOCUMENT ME!
- *
- * @return the current namespace context
- */
- NamespaceContext getNamespaceContext();
+ /**
+ * DOCUMENT ME!
+ *
+ * @return the current namespace context
+ */
+ NamespaceContext getNamespaceContext();
- /**
- * Sets the namespace context to be used when evaluating XPath expressions
- *
- * @param namespaceContext
- * DOCUMENT ME!
- */
- void setNamespaceContext(NamespaceContext namespaceContext);
+ /**
+ * Sets the namespace context to be used when evaluating XPath expressions
+ *
+ * @param namespaceContext DOCUMENT ME!
+ */
+ void setNamespaceContext(NamespaceContext namespaceContext);
- /**
- *
- * Sets the current NamespaceContext from a Map where the keys are the
- * String namespace prefixes and the values are the namespace URIs.
- *
- *
- * @param map
- * the map containing the namespace mappings
- */
- void setNamespaceURIs(Map map);
+ /**
+ * Sets the current NamespaceContext from a Map where the keys are the
+ * String namespace prefixes and the values are the namespace URIs.
+ *
+ * For example:
+ *
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.12 $
*/
public class DOMText extends DefaultText implements org.w3c.dom.Text {
public DOMText(String text) {
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dom/package-info.java b/fine-org-dom4j/src/main/java/org/dom4j/dom/package-info.java
new file mode 100644
index 000000000..cb74834f1
--- /dev/null
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dom/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * An implementation of the dom4j API which also supports the W3C object model.
+ */
+package org.dom4j.dom;
\ No newline at end of file
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dom/package.html b/fine-org-dom4j/src/main/java/org/dom4j/dom/package.html
deleted file mode 100644
index b86c30f3b..000000000
--- a/fine-org-dom4j/src/main/java/org/dom4j/dom/package.html
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-
-
-
-
An implementation of the dom4j API which also supports the
- W3C object model.
-
-
-
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/AttributeDecl.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/AttributeDecl.java
index 77f99eaaf..e20e7202c 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/dtd/AttributeDecl.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/AttributeDecl.java
@@ -13,9 +13,9 @@ package org.dom4j.dtd;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.7 $
*/
-public class AttributeDecl {
+public class AttributeDecl implements Decl {
/** Holds value of property elementName. */
private String elementName;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/Decl.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/Decl.java
new file mode 100644
index 000000000..f05d32df5
--- /dev/null
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/Decl.java
@@ -0,0 +1,7 @@
+package org.dom4j.dtd;
+
+/**
+ * Created by filip on 5.7.15.
+ */
+public interface Decl {
+}
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/ElementDecl.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/ElementDecl.java
index 9447e1873..c4abb3f63 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/dtd/ElementDecl.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/ElementDecl.java
@@ -13,9 +13,9 @@ package org.dom4j.dtd;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.6 $
*/
-public class ElementDecl {
+public class ElementDecl implements Decl {
/** Holds value of property name. */
private String name;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/ExternalEntityDecl.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/ExternalEntityDecl.java
index 645cbb642..c02da0381 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/dtd/ExternalEntityDecl.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/ExternalEntityDecl.java
@@ -14,9 +14,9 @@ package org.dom4j.dtd;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.9 $
*/
-public class ExternalEntityDecl {
+public class ExternalEntityDecl implements Decl {
/** Holds value of property name. */
private String name;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/InternalEntityDecl.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/InternalEntityDecl.java
index d53fc96de..cd6d46ebc 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/dtd/InternalEntityDecl.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/InternalEntityDecl.java
@@ -14,9 +14,9 @@ package org.dom4j.dtd;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.9 $
*/
-public class InternalEntityDecl {
+public class InternalEntityDecl implements Decl {
/** Holds value of property name. */
private String name;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/package-info.java b/fine-org-dom4j/src/main/java/org/dom4j/dtd/package-info.java
new file mode 100644
index 000000000..27b3cd690
--- /dev/null
+++ b/fine-org-dom4j/src/main/java/org/dom4j/dtd/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Classes to represent the DTD declarations. They are used inside the {@link org.dom4j.DocumentType} interface.
+ */
+package org.dom4j.dtd;
\ No newline at end of file
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/dtd/package.html b/fine-org-dom4j/src/main/java/org/dom4j/dtd/package.html
deleted file mode 100644
index af655947a..000000000
--- a/fine-org-dom4j/src/main/java/org/dom4j/dtd/package.html
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-
-
-
-
Classes to represent the DTD declarations. They are used inside the {@link org.dom4j.DocumentType} interface.
-
-
-
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMDocumentResult.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMDocumentResult.java
new file mode 100644
index 000000000..5f579bbe3
--- /dev/null
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMDocumentResult.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
+ *
+ * This software is open source.
+ * See the bottom of this file for the licence.
+ */
+
+package org.dom4j.io;
+
+import javax.xml.transform.sax.SAXResult;
+
+import org.w3c.dom.Document;
+
+import org.xml.sax.ContentHandler;
+import org.xml.sax.ext.LexicalHandler;
+
+/**
+ *
+ * DOMDocumentResult implements a JAXP {@link SAXResult} for a
+ * {@link org.w3c.dom.Document}.
+ *
+ *
+ * @author James Strachan
+ * @author Todd Wolff
+ * @version $Revision: 1.1 $
+ */
+public class DOMDocumentResult extends SAXResult {
+ private DOMSAXContentHandler contentHandler;
+
+ public DOMDocumentResult() {
+ this(new DOMSAXContentHandler());
+ }
+
+ public DOMDocumentResult(DOMSAXContentHandler contentHandler) {
+ this.contentHandler = contentHandler;
+ super.setHandler(this.contentHandler);
+ super.setLexicalHandler(this.contentHandler);
+ }
+
+ /**
+ * Retrieves w3c dom object generated via transformation
+ *
+ * @return the Document created by the transformation
+ */
+ public Document getDocument() {
+ return contentHandler.getDocument();
+ }
+
+ // Overloaded methods
+ // -------------------------------------------------------------------------
+ public void setHandler(ContentHandler handler) {
+ if (handler instanceof DOMSAXContentHandler) {
+ this.contentHandler = (DOMSAXContentHandler) handler;
+ super.setHandler(this.contentHandler);
+ }
+ }
+
+ public void setLexicalHandler(LexicalHandler handler) {
+ if (handler instanceof DOMSAXContentHandler) {
+ this.contentHandler = (DOMSAXContentHandler) handler;
+ super.setLexicalHandler(this.contentHandler);
+ }
+ }
+
+}
+
+/*
+ * Redistribution and use of this software and associated documentation
+ * ("Software"), with or without modification, are permitted provided that the
+ * following conditions are met:
+ *
+ * 1. Redistributions of source code must retain copyright statements and
+ * notices. Redistributions must also contain a copy of this document.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. The name "DOM4J" must not be used to endorse or promote products derived
+ * from this Software without prior written permission of MetaStuff, Ltd. For
+ * written permission, please contact dom4j-info@metastuff.com.
+ *
+ * 4. Products derived from this Software may not be called "DOM4J" nor may
+ * "DOM4J" appear in their names without prior written permission of MetaStuff,
+ * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
+ *
+ * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
+ *
+ * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
+ */
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMReader.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMReader.java
index 7debed853..0fc85a951 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMReader.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMReader.java
@@ -10,12 +10,8 @@ package org.dom4j.io;
import java.util.ArrayList;
import java.util.List;
-import org.dom4j.Branch;
-import org.dom4j.Document;
-import org.dom4j.DocumentFactory;
-import org.dom4j.Element;
-import org.dom4j.Namespace;
-import org.dom4j.QName;
+import org.dom4j.*;
+import org.dom4j.dom.DOMAttribute;
import org.dom4j.tree.NamespaceStack;
/**
@@ -25,7 +21,7 @@ import org.dom4j.tree.NamespaceStack;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.17 $
*/
public class DOMReader {
/** DocumentFactory used to create new document objects */
@@ -201,11 +197,10 @@ public class DOMReader {
if (attributeList != null) {
int size = attributeList.getLength();
- List attributes = new ArrayList(size);
+ List attributes = new ArrayList(size);
for (int i = 0; i < size; i++) {
org.w3c.dom.Node attribute = attributeList.item(i);
-
// Define all namespaces first then process attributes later
String name = attribute.getNodeName();
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMSAXContentHandler.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMSAXContentHandler.java
new file mode 100644
index 000000000..821590c9b
--- /dev/null
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMSAXContentHandler.java
@@ -0,0 +1,548 @@
+/*
+ * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
+ *
+ * This software is open source.
+ * See the bottom of this file for the licence.
+ */
+
+package org.dom4j.io;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.dom4j.Branch;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.Namespace;
+import org.dom4j.QName;
+import org.dom4j.dom.DOMAttribute;
+import org.dom4j.dom.DOMCDATA;
+import org.dom4j.dom.DOMComment;
+import org.dom4j.dom.DOMDocumentFactory;
+import org.dom4j.dom.DOMElement;
+import org.dom4j.dom.DOMText;
+import org.dom4j.tree.NamespaceStack;
+import org.w3c.dom.ProcessingInstruction;
+import org.xml.sax.Attributes;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.ext.LexicalHandler;
+import org.xml.sax.ext.Locator2;
+import org.xml.sax.helpers.DefaultHandler;
+
+/**
+ *
+ * SAXContentHandler builds W3C DOM object via SAX events.
+ *
+ * @author James Strachan
+ * @author Todd Wolff
+ *
+ *
+ */
+public class DOMSAXContentHandler extends DefaultHandler implements LexicalHandler {
+
+ /** The factory used to create new Document instances */
+ private DOMDocumentFactory documentFactory;
+
+ /** The document that is being built */
+ private Document document;
+
+ /** stack of Element objects */
+ private ElementStack elementStack;
+
+ /** stack of Namespace and QName objects */
+ private NamespaceStack namespaceStack;
+
+ /** the Locator */
+ private Locator locator;
+
+ /** Flag used to indicate that we are inside a CDATA section */
+ private boolean insideCDATASection;
+
+ /**
+ * buffer to hold contents of cdata section across multiple characters
+ * events
+ */
+ private StringBuffer cdataText;
+
+ /** The number of namespaces that are declared in the current scope */
+ private int declaredNamespaceIndex;
+
+ private InputSource inputSource;
+
+ /** The current element we are on */
+ private Element currentElement;
+
+ /** The entity resolver */
+ private EntityResolver entityResolver;
+
+ /** Whether adjacent text nodes should be merged */
+ private boolean mergeAdjacentText = false;
+
+ /** Have we added text to the buffer */
+ private boolean textInTextBuffer = false;
+
+ /** Should we ignore comments */
+ private boolean ignoreComments = false;
+
+ /** Buffer used to concatenate text together */
+ private StringBuffer textBuffer;
+
+ /** Holds value of property stripWhitespaceText. */
+ private boolean stripWhitespaceText = false;
+
+ public DOMSAXContentHandler() {
+ this((DOMDocumentFactory)DOMDocumentFactory.getInstance());
+ }
+
+ public DOMSAXContentHandler(DOMDocumentFactory documentFactory) {
+ this.documentFactory = documentFactory;
+ this.elementStack = createElementStack();
+ this.namespaceStack = new NamespaceStack(documentFactory);
+ }
+
+ /**
+ * Retrieves w3c document object built via generated sax events.
+ *
+ * @return the document that has been or is being built
+ */
+ public org.w3c.dom.Document getDocument() {
+ if (document == null) {
+ document = createDocument();
+ }
+
+ return (org.w3c.dom.Document)document;
+ }
+
+ // ContentHandler interface
+ // -------------------------------------------------------------------------
+ public void setDocumentLocator(Locator documentLocator) {
+ this.locator = documentLocator;
+ }
+
+ public void processingInstruction(String target, String data)
+ throws SAXException {
+ if (mergeAdjacentText && textInTextBuffer) {
+ completeCurrentTextNode();
+ }
+ ProcessingInstruction pi = (ProcessingInstruction)documentFactory.createProcessingInstruction(target, data);
+ if (currentElement != null) {
+ ((org.w3c.dom.Element)currentElement).appendChild(pi);
+ } else {
+ getDocument().appendChild(pi);
+ }
+ }
+
+ public void startPrefixMapping(String prefix, String uri)
+ throws SAXException {
+ namespaceStack.push(prefix, uri);
+ }
+
+ public void endPrefixMapping(String prefix) throws SAXException {
+ namespaceStack.pop(prefix);
+ declaredNamespaceIndex = namespaceStack.size();
+ }
+
+ public void startDocument() throws SAXException {
+ document = null;
+ currentElement = null;
+
+ elementStack.clear();
+
+ namespaceStack.clear();
+ declaredNamespaceIndex = 0;
+
+ if (mergeAdjacentText && (textBuffer == null)) {
+ textBuffer = new StringBuffer();
+ }
+
+ textInTextBuffer = false;
+ }
+
+ public void endDocument() throws SAXException {
+ namespaceStack.clear();
+ elementStack.clear();
+ currentElement = null;
+ textBuffer = null;
+ }
+
+ public void startElement(String namespaceURI, String localName,
+ String qualifiedName, Attributes attributes) throws SAXException {
+ if (mergeAdjacentText && textInTextBuffer) {
+ completeCurrentTextNode();
+ }
+
+ QName qName = namespaceStack.getQName(namespaceURI, localName,
+ qualifiedName);
+
+ Branch branch = currentElement;
+
+ if (branch == null) {
+ branch = (org.dom4j.Document)getDocument();
+ }
+
+ Element element = new DOMElement(qName);
+ branch.add(element);
+
+ // add all declared namespaces
+ addDeclaredNamespaces(element);
+
+ // now lets add all attribute values
+ addAttributes(element, attributes);
+
+ elementStack.pushElement(element);
+ currentElement = element;
+
+ }
+
+ public void endElement(String namespaceURI, String localName, String qName)
+ throws SAXException {
+ if (mergeAdjacentText && textInTextBuffer) {
+ completeCurrentTextNode();
+ }
+
+ elementStack.popElement();
+ currentElement = elementStack.peekElement();
+ }
+
+ public void characters(char[] ch, int start, int end) throws SAXException {
+ if (end == 0) {
+ return;
+ }
+
+ if (currentElement != null) {
+ if (insideCDATASection) {
+ if (mergeAdjacentText && textInTextBuffer) {
+ completeCurrentTextNode();
+ }
+ cdataText.append(new String(ch, start, end));
+ } else {
+ if (mergeAdjacentText) {
+ textBuffer.append(ch, start, end);
+ textInTextBuffer = true;
+ } else {
+ DOMText text = new DOMText(new String(ch, start, end));
+ ((DOMElement)currentElement).add(text);
+ }
+ }
+ }
+ }
+
+ // ErrorHandler interface
+ // -------------------------------------------------------------------------
+
+ /**
+ * This method is called when a warning occurs during the parsing of the
+ * document. This method does nothing.
+ *
+ * @param exception
+ * DOCUMENT ME!
+ *
+ * @throws SAXException
+ * DOCUMENT ME!
+ */
+ public void warning(SAXParseException exception) throws SAXException {
+ // ignore warnings by default
+ }
+
+ /**
+ * This method is called when an error is detected during parsing such as a
+ * validation error. This method rethrows the exception
+ *
+ * @param exception
+ * DOCUMENT ME!
+ *
+ * @throws SAXException
+ * DOCUMENT ME!
+ */
+ public void error(SAXParseException exception) throws SAXException {
+ throw exception;
+ }
+
+ /**
+ * This method is called when a fatal error occurs during parsing. This
+ * method rethrows the exception
+ *
+ * @param exception
+ * DOCUMENT ME!
+ *
+ * @throws SAXException
+ * DOCUMENT ME!
+ */
+ public void fatalError(SAXParseException exception) throws SAXException {
+ throw exception;
+ }
+
+ // LexicalHandler interface
+ // -------------------------------------------------------------------------
+ public void startDTD(String name, String publicId, String systemId)
+ throws SAXException {
+ // not supported
+ }
+
+ public void endDTD() throws SAXException {
+ // not supported
+ }
+
+ public void startEntity(String name) throws SAXException {
+ // not supported
+ }
+
+ public void endEntity(String name) throws SAXException {
+ // not supported
+ }
+
+ public void startCDATA() throws SAXException {
+ insideCDATASection = true;
+ cdataText = new StringBuffer();
+ }
+
+ public void endCDATA() throws SAXException {
+ insideCDATASection = false;
+ DOMCDATA cdata = new DOMCDATA(cdataText.toString());
+ ((DOMElement)currentElement).add(cdata);
+ }
+
+ public void comment(char[] ch, int start, int end) throws SAXException {
+ if (!ignoreComments) {
+ if (mergeAdjacentText && textInTextBuffer) {
+ completeCurrentTextNode();
+ }
+
+ String text = new String(ch, start, end);
+
+ if (text.length() > 0) {
+ DOMComment domComment = new DOMComment(text);
+ if (currentElement != null) {
+ ((DOMElement)currentElement).add(domComment);
+ } else {
+ getDocument().appendChild(domComment);
+ }
+ }
+ }
+ }
+
+ // Properties
+ // -------------------------------------------------------------------------
+ public ElementStack getElementStack() {
+ return elementStack;
+ }
+
+ public void setElementStack(ElementStack elementStack) {
+ this.elementStack = elementStack;
+ }
+
+ public EntityResolver getEntityResolver() {
+ return entityResolver;
+ }
+
+ public void setEntityResolver(EntityResolver entityResolver) {
+ this.entityResolver = entityResolver;
+ }
+
+ public InputSource getInputSource() {
+ return inputSource;
+ }
+
+ public void setInputSource(InputSource inputSource) {
+ this.inputSource = inputSource;
+ }
+
+ /**
+ * Returns whether adjacent text nodes should be merged together.
+ *
+ * @return Value of property mergeAdjacentText.
+ */
+ public boolean isMergeAdjacentText() {
+ return mergeAdjacentText;
+ }
+
+ /**
+ * Sets whether or not adjacent text nodes should be merged together when
+ * parsing.
+ *
+ * @param mergeAdjacentText
+ * New value of property mergeAdjacentText.
+ */
+ public void setMergeAdjacentText(boolean mergeAdjacentText) {
+ this.mergeAdjacentText = mergeAdjacentText;
+ }
+
+ /**
+ * Sets whether whitespace between element start and end tags should be
+ * ignored
+ *
+ * @return Value of property stripWhitespaceText.
+ */
+ public boolean isStripWhitespaceText() {
+ return stripWhitespaceText;
+ }
+
+ /**
+ * Sets whether whitespace between element start and end tags should be
+ * ignored.
+ *
+ * @param stripWhitespaceText
+ * New value of property stripWhitespaceText.
+ */
+ public void setStripWhitespaceText(boolean stripWhitespaceText) {
+ this.stripWhitespaceText = stripWhitespaceText;
+ }
+
+ /**
+ * Returns whether we should ignore comments or not.
+ *
+ * @return boolean
+ */
+ public boolean isIgnoreComments() {
+ return ignoreComments;
+ }
+
+ /**
+ * Sets whether we should ignore comments or not.
+ *
+ * @param ignoreComments
+ * whether we should ignore comments or not.
+ */
+ public void setIgnoreComments(boolean ignoreComments) {
+ this.ignoreComments = ignoreComments;
+ }
+
+ // Implementation methods
+ // -------------------------------------------------------------------------
+
+ protected void completeCurrentTextNode() {
+ if (stripWhitespaceText) {
+ boolean whitespace = true;
+ for (int i = 0, size = textBuffer.length(); i < size; i++) {
+ if (!Character.isWhitespace(textBuffer.charAt(i))) {
+ whitespace = false;
+
+ break;
+ }
+ }
+ if (!whitespace) {
+ DOMText domText = new DOMText(textBuffer.toString());
+ ((DOMElement)currentElement).add(domText);
+ }
+ } else {
+ DOMText domText = new DOMText(textBuffer.toString());
+ ((DOMElement)currentElement).add(domText);
+ }
+
+ textBuffer.setLength(0);
+ textInTextBuffer = false;
+ }
+
+ protected Document createDocument() {
+ String encoding = getEncoding();
+ Document doc = documentFactory.createDocument(encoding);
+
+ // set the EntityResolver
+ doc.setEntityResolver(entityResolver);
+
+ if (inputSource != null) {
+ doc.setName(inputSource.getSystemId());
+ }
+
+ return doc;
+ }
+
+ private String getEncoding() {
+ if (locator == null) {
+ return null;
+ }
+
+ if (locator instanceof Locator2) {
+ return ((Locator2) locator).getEncoding();
+ }
+
+ // couldn't determine encoding, returning null...
+ return null;
+ }
+
+ protected void addDeclaredNamespaces(Element element) {
+ for (int size = namespaceStack.size(); declaredNamespaceIndex < size;
+ declaredNamespaceIndex++) {
+ Namespace namespace = namespaceStack
+ .getNamespace(declaredNamespaceIndex);
+ String attributeName = attributeNameForNamespace(namespace);
+ ((DOMElement)element).setAttribute(attributeName, namespace.getURI());
+ }
+ }
+
+ protected void addAttributes(Element element, Attributes attributes) {
+ int size = attributes.getLength();
+ for (int i = 0; i < size; i++) {
+ String attributeQName = attributes.getQName(i);
+ if (!attributeQName.startsWith("xmlns")) {
+ String attributeURI = attributes.getURI(i);
+ String attributeLocalName = attributes.getLocalName(i);
+ String attributeValue = attributes.getValue(i);
+ QName qName = namespaceStack.getAttributeQName(
+ attributeURI, attributeLocalName, attributeQName);
+ DOMAttribute domAttribute = new DOMAttribute(qName, attributeValue);
+ ((DOMElement)element).setAttributeNode(domAttribute);
+ }
+ }
+ }
+
+ protected ElementStack createElementStack() {
+ return new ElementStack();
+ }
+
+ protected String attributeNameForNamespace(Namespace namespace) {
+ String xmlns = "xmlns";
+ String prefix = namespace.getPrefix();
+
+ if (prefix.length() > 0) {
+ return xmlns + ":" + prefix;
+ }
+
+ return xmlns;
+ }
+
+}
+
+/*
+ * Redistribution and use of this software and associated documentation
+ * ("Software"), with or without modification, are permitted provided that the
+ * following conditions are met:
+ *
+ * 1. Redistributions of source code must retain copyright statements and
+ * notices. Redistributions must also contain a copy of this document.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. The name "DOM4J" must not be used to endorse or promote products derived
+ * from this Software without prior written permission of MetaStuff, Ltd. For
+ * written permission, please contact dom4j-info@metastuff.com.
+ *
+ * 4. Products derived from this Software may not be called "DOM4J" nor may
+ * "DOM4J" appear in their names without prior written permission of MetaStuff,
+ * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
+ *
+ * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
+ *
+ * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
+ */
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMWriter.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMWriter.java
index aa911be0f..a074dbe51 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DOMWriter.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DOMWriter.java
@@ -9,28 +9,18 @@ package org.dom4j.io;
import java.util.List;
-import org.dom4j.Attribute;
-import org.dom4j.CDATA;
-import org.dom4j.Comment;
-import org.dom4j.Document;
-import org.dom4j.DocumentException;
-import org.dom4j.Element;
-import org.dom4j.Entity;
-import org.dom4j.Namespace;
-import org.dom4j.ProcessingInstruction;
-import org.dom4j.Text;
+import org.dom4j.*;
+import org.dom4j.dtd.Decl;
import org.dom4j.tree.NamespaceStack;
import org.w3c.dom.DOMImplementation;
/**
- *
* DOMWriter takes a DOM4J tree and outputs it as a W3C DOM
* object
- *
- *
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.17 $
*/
public class DOMWriter {
private static boolean loggedWarning = false;
@@ -46,7 +36,7 @@ public class DOMWriter {
};
// the Class used to create new DOM Document instances
- private Class domDocumentClass;
+ private Class domDocumentClass;
/** stack of Namespace objects */
private NamespaceStack namespaceStack = new NamespaceStack();
@@ -54,20 +44,19 @@ public class DOMWriter {
public DOMWriter() {
}
- public DOMWriter(Class domDocumentClass) {
+ public DOMWriter(Class domDocumentClass) {
this.domDocumentClass = domDocumentClass;
}
- public Class getDomDocumentClass() throws DocumentException {
- Class result = domDocumentClass;
+ public Class getDomDocumentClass() throws DocumentException {
+ Class result = domDocumentClass;
if (result == null) {
// lets try and find one in the classpath
int size = DEFAULT_DOM_DOCUMENT_CLASSES.length;
- for (int i = 0; i < size; i++) {
+ for (String name : DEFAULT_DOM_DOCUMENT_CLASSES) {
try {
- String name = DEFAULT_DOM_DOCUMENT_CLASSES[i];
result = Class.forName(name, true, DOMWriter.class
.getClassLoader());
@@ -89,10 +78,10 @@ public class DOMWriter {
* the writer when creating DOM documents.
*
* @param domDocumentClass
- * is the Class implementing the {@linkorg.w3c.dom.Document}
+ * is the Class implementing the {@link org.w3c.dom.Document}
* interface
*/
- public void setDomDocumentClass(Class domDocumentClass) {
+ public void setDomDocumentClass(Class domDocumentClass) {
this.domDocumentClass = domDocumentClass;
}
@@ -148,28 +137,22 @@ public class DOMWriter {
}
protected void appendDOMTree(org.w3c.dom.Document domDocument,
- org.w3c.dom.Node domCurrent, List content) {
- int size = content.size();
-
- for (int i = 0; i < size; i++) {
- Object object = content.get(i);
-
- if (object instanceof Element) {
- appendDOMTree(domDocument, domCurrent, (Element) object);
- } else if (object instanceof String) {
- appendDOMTree(domDocument, domCurrent, (String) object);
- } else if (object instanceof Text) {
- Text text = (Text) object;
+ org.w3c.dom.Node domCurrent, List content) {
+ for (Node node : content) {
+ if (node instanceof Element) {
+ appendDOMTree(domDocument, domCurrent, (Element) node);
+ } else if (node instanceof Text) {
+ Text text = (Text) node;
appendDOMTree(domDocument, domCurrent, text.getText());
- } else if (object instanceof CDATA) {
- appendDOMTree(domDocument, domCurrent, (CDATA) object);
- } else if (object instanceof Comment) {
- appendDOMTree(domDocument, domCurrent, (Comment) object);
- } else if (object instanceof Entity) {
- appendDOMTree(domDocument, domCurrent, (Entity) object);
- } else if (object instanceof ProcessingInstruction) {
+ } else if (node instanceof CDATA) {
+ appendDOMTree(domDocument, domCurrent, (CDATA) node);
+ } else if (node instanceof Comment) {
+ appendDOMTree(domDocument, domCurrent, (Comment) node);
+ } else if (node instanceof Entity) {
+ appendDOMTree(domDocument, domCurrent, (Entity) node);
+ } else if (node instanceof ProcessingInstruction) {
appendDOMTree(domDocument, domCurrent,
- (ProcessingInstruction) object);
+ (ProcessingInstruction) node);
}
}
}
@@ -192,7 +175,7 @@ public class DOMWriter {
}
// add the additional declared namespaces
- List declaredNamespaces = element.declaredNamespaces();
+ List declaredNamespaces = element.declaredNamespaces();
for (int i = 0, size = declaredNamespaces.size(); i < size; i++) {
Namespace namespace = (Namespace) declaredNamespaces.get(i);
@@ -204,8 +187,7 @@ public class DOMWriter {
}
// add the attributes
- for (int i = 0, size = element.attributeCount(); i < size; i++) {
- Attribute attribute = (Attribute) element.attribute(i);
+ for (Attribute attribute : element.attributes()) {
String attUri = attribute.getNamespaceURI();
String attName = attribute.getQualifiedName();
String value = attribute.getValue();
@@ -294,7 +276,7 @@ public class DOMWriter {
result = createDomDocumentViaJAXP();
if (result == null) {
- Class theClass = getDomDocumentClass();
+ Class theClass = getDomDocumentClass();
try {
result = (org.w3c.dom.Document) theClass.newInstance();
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DispatchHandler.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DispatchHandler.java
index b712b5b3e..a2ec88acb 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DispatchHandler.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DispatchHandler.java
@@ -27,7 +27,7 @@ import org.dom4j.ElementPath;
*
*
* @author Dave White
- * @version $Revision$
+ * @version $Revision: 1.11 $
*/
class DispatchHandler implements ElementHandler {
/** Whether the parser is at the root element or not */
@@ -37,16 +37,16 @@ class DispatchHandler implements ElementHandler {
private String path;
/** maintains a stack of previously encountered paths */
- private ArrayList pathStack;
+ private ArrayList pathStack;
/** maintains a stack of previously encountered handlers */
- private ArrayList handlerStack;
+ private ArrayList handlerStack;
/**
* HashMap maintains the mapping between element paths and
* handlers
*/
- private HashMap handlers;
+ private HashMap handlers;
/**
* ElementHandler to use by default for element paths with no
@@ -57,9 +57,9 @@ class DispatchHandler implements ElementHandler {
public DispatchHandler() {
atRoot = true;
path = "/";
- pathStack = new ArrayList();
- handlerStack = new ArrayList();
- handlers = new HashMap();
+ pathStack = new ArrayList();
+ handlerStack = new ArrayList();
+ handlers = new HashMap();
}
/**
@@ -86,7 +86,7 @@ class DispatchHandler implements ElementHandler {
* @return DOCUMENT ME!
*/
public ElementHandler removeHandler(String handlerPath) {
- return (ElementHandler) handlers.remove(handlerPath);
+ return handlers.remove(handlerPath);
}
/**
@@ -111,7 +111,7 @@ class DispatchHandler implements ElementHandler {
* @return the registered handler
*/
public ElementHandler getHandler(String handlerPath) {
- return (ElementHandler) handlers.get(handlerPath);
+ return handlers.get(handlerPath);
}
/**
@@ -177,7 +177,7 @@ class DispatchHandler implements ElementHandler {
if ((handlers != null) && (handlers.containsKey(path))) {
// The current node has a handler associated with it.
// Find the handler and save it on the handler stack.
- ElementHandler handler = (ElementHandler) handlers.get(path);
+ ElementHandler handler = handlers.get(path);
handlerStack.add(handler);
// Call the handlers onStart method.
@@ -195,7 +195,7 @@ class DispatchHandler implements ElementHandler {
if ((handlers != null) && (handlers.containsKey(path))) {
// This node has a handler associated with it.
// Find the handler and pop it from the handler stack.
- ElementHandler handler = (ElementHandler) handlers.get(path);
+ ElementHandler handler = handlers.get(path);
handlerStack.remove(handlerStack.size() - 1);
// Call the handlers onEnd method
@@ -209,7 +209,7 @@ class DispatchHandler implements ElementHandler {
}
// Set path back to its parent
- path = (String) pathStack.remove(pathStack.size() - 1);
+ path = pathStack.remove(pathStack.size() - 1);
if (pathStack.size() == 0) {
atRoot = true;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentInputSource.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentInputSource.java
index a24bbb92c..35c8ece51 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentInputSource.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentInputSource.java
@@ -23,7 +23,7 @@ import org.xml.sax.InputSource;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.8 $
*/
class DocumentInputSource extends InputSource {
/** The document source */
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentResult.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentResult.java
index efca88575..3bca881ba 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentResult.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentResult.java
@@ -21,7 +21,7 @@ import org.xml.sax.ext.LexicalHandler;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.8 $
*/
public class DocumentResult extends SAXResult {
private SAXContentHandler contentHandler;
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentSource.java b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentSource.java
index 2745d6cfa..1cc206930 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentSource.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/DocumentSource.java
@@ -17,13 +17,11 @@ import org.xml.sax.XMLFilter;
import org.xml.sax.XMLReader;
/**
- *
* DocumentSource implements a JAXP {@link SAXSource}for a
- * {@linkDocument}.
- *
- *
+ * {@link Document}.
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.10 $
*/
public class DocumentSource extends SAXSource {
/**
@@ -93,7 +91,7 @@ public class DocumentSource extends SAXSource {
}
/**
- * This method is not supported as this source is always a {@linkDocument}
+ * This method is not supported as this source is always a {@link Document}
* instance.
*
* @param inputSource
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/ElementStack.java b/fine-org-dom4j/src/main/java/org/dom4j/io/ElementStack.java
index 6466ac03d..1284dd2aa 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/ElementStack.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/ElementStack.java
@@ -20,7 +20,7 @@ import org.dom4j.ElementPath;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.14 $
*/
class ElementStack implements ElementPath {
/** stack of Element objects */
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/HTMLWriter.java b/fine-org-dom4j/src/main/java/org/dom4j/io/HTMLWriter.java
index 3a0b2316f..719d822e9 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/HTMLWriter.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/HTMLWriter.java
@@ -26,25 +26,21 @@ import org.dom4j.Node;
import org.xml.sax.SAXException;
/**
- *
* HTMLWriter takes a DOM4J tree and formats it to a stream as
* HTML. This formatter is similar to XMLWriter but it outputs the text of CDATA
* and Entity sections rather than the serialised format as in XML, it has an
* XHTML mode, it retains whitespace in certain elements such as <PRE>,
* and it supports certain elements which have no corresponding close tag such
* as for <BR> and <P>.
- *
- *
- *
+ *
* The OutputFormat passed in to the constructor is checked for isXHTML() and
* isExpandEmptyElements(). See {@link OutputFormat OutputFormat}for details.
* Here are the rules for this class based on an OutputFormat, "format",
- * passed in to the constructor:
+ * passed in to the constructor:
*
*
*
If an element is in {@link #getOmitElementCloseSet()
* getOmitElementCloseSet}, then it is treated specially:
- *
*
*
It never expands, since some browsers treat this as two separate
* Horizontal Rules: <HR></HR>
@@ -54,7 +50,6 @@ import org.xml.sax.SAXException;
* "/", but that's better than when it refuses to recognize this: <hr/>
* which it thinks is an element named "HR/".
*
- *
*
*
If {@link org.dom4j.io.OutputFormat#isXHTML() format.isXHTML()}, all
* elements must have either a close element, or be a closed single tag.
@@ -62,41 +57,21 @@ import org.xml.sax.SAXException;
* format.isExpandEmptyElements()}() is true, all elements are expanded except
* as above.
*
- *
* Examples
- *
- *
- *
- *
- *
- *
* If isXHTML == true, CDATA sections look like this:
- *
- *
+
+ * Basically, {@link OutputFormat#isXHTML()} ==
* true will produce valid XML, while {@link
- * org.dom4j.io.OutputFormat#isExpandEmptyElements()
- * format.isExpandEmptyElements()} determines whether empty elements are
+ * OutputFormat#isExpandEmptyElements()} determines whether empty elements are
* expanded if isXHTML is true, excepting the special HTML single tags.
- *
- *
- *
+ *
* Also, HTMLWriter handles tags whose contents should be preformatted, that is,
* whitespace-preserved. By default, this set includes the tags <PRE>,
* <SCRIPT>, <STYLE>, and <TEXTAREA>, case insensitively. It
@@ -107,29 +82,15 @@ import org.xml.sax.SAXException;
* However, the parser you use may store comments with linefeed-only text nodes
* (\n) even if your platform uses another line.separator character, and
* HTMLWriter outputs Comment nodes exactly as the DOM is set up by the parser.
- * See examples and discussion here: {@link#setPreformattedTags(java.util.Set)
- * setPreformattedTags}
- *
- *
- *
+ * See examples and discussion here: {@link #setPreformattedTags(java.util.Set)}
+ *
* Examples
- *
- *
- *
* Pretty Printing
- *
- *
- *
* This example shows how to pretty print a string containing a valid HTML
* document to a string. You can also just call the static methods of this
- * class:
- * {@link #prettyPrintHTML(String) prettyPrintHTML(String)}or
- * {@link #prettyPrintHTML(String,boolean,boolean,boolean,boolean)
- * prettyPrintHTML(String,boolean,boolean,boolean,boolean)} or,
- * {@link #prettyPrintXHTML(String) prettyPrintXHTML(String)}for XHTML (note
- * the X)
- *
- *
+ * class: {@link #prettyPrintHTML(String)}or {@link #prettyPrintHTML(String,boolean,boolean,boolean,boolean)}
+ * or {@link #prettyPrintXHTML(String)} for XHTML (note the X)
+ *
*
* This example shows how to create a "squeezed" document, but one that will
* work in browsers even if the browser line length is limited. No newlines are
* included, no extra whitespace at all, except where it it required by
* {@link #setPreformattedTags(java.util.Set) setPreformattedTags}.
- *
- *
+ *
* @author James Strachan
* @author Laramie Crocker
- * @version $Revision$
+ * @version $Revision: 1.21 $
*/
public class HTMLWriter extends XMLWriter {
private static String lineSeparator = System.getProperty("line.separator");
- protected static final HashSet DEFAULT_PREFORMATTED_TAGS;
+ protected static final HashSet DEFAULT_PREFORMATTED_TAGS;
static {
// If you change this list, update the javadoc examples, above in the
// class javadoc, in writeElement, and in setPreformattedTags().
- DEFAULT_PREFORMATTED_TAGS = new HashSet();
+ DEFAULT_PREFORMATTED_TAGS = new HashSet();
DEFAULT_PREFORMATTED_TAGS.add("PRE");
DEFAULT_PREFORMATTED_TAGS.add("SCRIPT");
DEFAULT_PREFORMATTED_TAGS.add("STYLE");
@@ -201,7 +158,7 @@ public class HTMLWriter extends XMLWriter {
DEFAULT_HTML_FORMAT.setSuppressDeclaration(true);
}
- private Stack formatStack = new Stack();
+ private Stack formatStack = new Stack();
private String lastText = "";
@@ -210,13 +167,13 @@ public class HTMLWriter extends XMLWriter {
// legal values are 0+, but -1 signifies lazy initialization.
private int newLineAfterNTags = -1;
- private HashSet preformattedTags = DEFAULT_PREFORMATTED_TAGS;
+ private HashSet preformattedTags = DEFAULT_PREFORMATTED_TAGS;
/**
* Used to store the qualified element names which should have no close
* element tag
*/
- private HashSet omitElementCloseSet;
+ private HashSet omitElementCloseSet;
public HTMLWriter(Writer writer) {
super(writer, DEFAULT_HTML_FORMAT);
@@ -349,9 +306,9 @@ public class HTMLWriter extends XMLWriter {
qualifiedName.toUpperCase());
}
- private HashSet internalGetOmitElementCloseSet() {
+ private HashSet internalGetOmitElementCloseSet() {
if (omitElementCloseSet == null) {
- omitElementCloseSet = new HashSet();
+ omitElementCloseSet = new HashSet();
loadOmitElementCloseSet(omitElementCloseSet);
}
@@ -359,7 +316,7 @@ public class HTMLWriter extends XMLWriter {
}
// If you change this, change the javadoc for getOmitElementCloseSet.
- protected void loadOmitElementCloseSet(Set set) {
+ protected void loadOmitElementCloseSet(Set set) {
set.add("AREA");
set.add("BASE");
set.add("BR");
@@ -382,8 +339,8 @@ public class HTMLWriter extends XMLWriter {
*
* @return A clone of the Set.
*/
- public Set getOmitElementCloseSet() {
- return (Set) (internalGetOmitElementCloseSet().clone());
+ public Set getOmitElementCloseSet() {
+ return (Set) (internalGetOmitElementCloseSet().clone());
}
/**
@@ -402,21 +359,17 @@ public class HTMLWriter extends XMLWriter {
* @param newSet
* DOCUMENT ME!
*/
- public void setOmitElementCloseSet(Set newSet) {
+ public void setOmitElementCloseSet(Set newSet) {
// resets, and safely empties it out if newSet is null.
- omitElementCloseSet = new HashSet();
+ omitElementCloseSet = new HashSet();
if (newSet != null) {
- omitElementCloseSet = new HashSet();
-
- Object aTag;
- Iterator iter = newSet.iterator();
+ omitElementCloseSet = new HashSet();
- while (iter.hasNext()) {
- aTag = iter.next();
+ for (String aTag : newSet) {
if (aTag != null) {
- omitElementCloseSet.add(aTag.toString().toUpperCase());
+ omitElementCloseSet.add(aTag.toUpperCase());
}
}
}
@@ -424,22 +377,18 @@ public class HTMLWriter extends XMLWriter {
/**
* @see #setPreformattedTags(java.util.Set) setPreformattedTags
+ *
+ * @return DOCUMENT ME!
*/
- public Set getPreformattedTags() {
- return (Set) (preformattedTags.clone());
+ public Set getPreformattedTags() {
+ return (Set) (preformattedTags.clone());
}
/**
- *
* Override the default set, which includes PRE, SCRIPT, STYLE, and
* TEXTAREA, case insensitively.
- *
- *
- *
+ *
* Setting Preformatted Tags
- *
- *
- *
* Pass in a Set of Strings, one for each tag name that should be treated
* like a PRE tag. You may pass in null or an empty Set to assign the empty
* set, in which case no tags will be treated as preformatted, except that
@@ -448,9 +397,7 @@ public class HTMLWriter extends XMLWriter {
* preserved, including whitespace on the same line preceding the close tag.
* This will generally make the close tag not line up with the start tag,
* but it preserves the intention of the whitespace within the tag.
- *
- *
- *
+ *
* The browser considers leading whitespace before the close tag to be
* significant, but leading whitespace before the open tag to be
* insignificant. For example, if the HTML author doesn't put the close
@@ -459,13 +406,8 @@ public class HTMLWriter extends XMLWriter {
* the HTML author's intent. Similarly, in a PRE, the browser treats a
* flushed left close PRE tag as different from a close tag with leading
* whitespace. Again, this must be left up to the HTML author.
- *
- *
- *
+ *
* Examples
- *
- *
- *
* Here is an example of how you can set the PreformattedTags list using
* setPreformattedTags to include IFRAME, as well as the default set, if you
* have an instance of this class named myHTMLWriter:
@@ -519,29 +461,21 @@ public class HTMLWriter extends XMLWriter {
*
*
*
- *
- *
- *
- *
+ *
* @param newSet
* DOCUMENT ME!
*/
- public void setPreformattedTags(Set newSet) {
+ public void setPreformattedTags(Set newSet) {
// no fancy merging, just set it, assuming they did a
// getExcludeTrimTags() first if they wanted to preserve the default
// set.
// resets, and safely empties it out if newSet is null.
- preformattedTags = new HashSet();
+ preformattedTags = new HashSet();
if (newSet != null) {
- Object aTag;
- Iterator iter = newSet.iterator();
-
- while (iter.hasNext()) {
- aTag = iter.next();
-
+ for (String aTag : newSet) {
if (aTag != null) {
- preformattedTags.add(aTag.toString().toUpperCase());
+ preformattedTags.add(aTag.toUpperCase());
}
}
}
@@ -687,9 +621,9 @@ public class HTMLWriter extends XMLWriter {
* close tags off of the default omitElementCloseSet set. Use one of
* the write methods if you want stream output.
*
- * @throws java.io.IOException
- * @throws java.io.UnsupportedEncodingException
- * @throws org.dom4j.DocumentException
+ * @throws java.io.IOException DOCUMENT ME!
+ * @throws java.io.UnsupportedEncodingException DOCUMENT ME!
+ * @throws org.dom4j.DocumentException DOCUMENT ME!
*/
public static String prettyPrintHTML(String html)
throws java.io.IOException, java.io.UnsupportedEncodingException,
@@ -709,9 +643,9 @@ public class HTMLWriter extends XMLWriter {
* converted to XHTML empty tags: <HR/> Use one of the write
* methods if you want stream output.
*
- * @throws java.io.IOException
- * @throws java.io.UnsupportedEncodingException
- * @throws org.dom4j.DocumentException
+ * @throws java.io.IOException DOCUMENT ME!
+ * @throws java.io.UnsupportedEncodingException DOCUMENT ME!
+ * @throws org.dom4j.DocumentException DOCUMENT ME!
*/
public static String prettyPrintXHTML(String html)
throws java.io.IOException, java.io.UnsupportedEncodingException,
@@ -739,9 +673,9 @@ public class HTMLWriter extends XMLWriter {
* override allows you to specify various formatter options. Use one
* of the write methods if you want stream output.
*
- * @throws java.io.IOException
- * @throws java.io.UnsupportedEncodingException
- * @throws org.dom4j.DocumentException
+ * @throws java.io.IOException DOCUMENT ME!
+ * @throws java.io.UnsupportedEncodingException DOCUMENT ME!
+ * @throws org.dom4j.DocumentException DOCUMENT ME!
*/
public static String prettyPrintHTML(String html, boolean newlines,
boolean trim, boolean isXHTML, boolean expandEmpty)
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/JAXPHelper.java b/fine-org-dom4j/src/main/java/org/dom4j/io/JAXPHelper.java
index 790d5dc00..e0aa8ebab 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/JAXPHelper.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/JAXPHelper.java
@@ -20,7 +20,7 @@ import org.xml.sax.XMLReader;
* such that dom4j can work without JAXP on the CLASSPATH
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.7 $
*/
class JAXPHelper {
protected JAXPHelper() {
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/OutputFormat.java b/fine-org-dom4j/src/main/java/org/dom4j/io/OutputFormat.java
index b30e1ca2e..c3acf1434 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/OutputFormat.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/OutputFormat.java
@@ -8,13 +8,11 @@
package org.dom4j.io;
/**
- *
* OutputFormat represents the format configuration used by
- * {@linkXMLWriter}and its base classes to format the XML output
- *
- *
+ * {@link XMLWriter}and its base classes to format the XML output
+ *
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.17 $
*/
public class OutputFormat implements Cloneable {
/** standard value to indent by, if we are indenting */
@@ -279,21 +277,14 @@ public class OutputFormat implements Cloneable {
}
/**
- *
* This will set whether the text is output verbatim (false) or with
* whitespace stripped as per {@link
* org.dom4j.Element#getTextTrim()}.
- *
- *
- *
- *
- *
- *
+ *
* Default: false
- *
- *
+ *
* @param trimText
- * boolean true=>trim the whitespace, false=>use
+ * boolean true → trim the whitespace, false → use
* text verbatim
*/
public void setTrimText(boolean trimText) {
@@ -305,7 +296,6 @@ public class OutputFormat implements Cloneable {
}
/**
- *
* Ensure that text immediately preceded by or followed by an element will
* be "padded" with a single space. This is used to allow make
* browser-friendly HTML, avoiding trimText's transformation of, e.g.,
@@ -314,17 +304,12 @@ public class OutputFormat implements Cloneable {
* (the latter will run the three separate words together into a single
* word). This setting is not too useful if you haven't also called
* {@link #setTrimText}.
- *
- *
- *
+ *
* The padding string will only be added if the text itself starts or ends
* with some whitespace characters.
- *
- *
- *
+ *
* Default: false
- *
- *
+ *
* @param padText
* boolean if true, pad string-element boundaries
*/
@@ -337,11 +322,10 @@ public class OutputFormat implements Cloneable {
}
/**
- *
* This will set the indent String to use; this is usually a
* String of empty spaces. If you pass null, or the empty
* string (""), then no indentation will happen.
- *
* This will set the indent String's size; an indentSize of
* 4 would result in the indention being equivalent to the
* String " " (four space characters).
- *
- *
+ *
* @param indentSize
* int number of spaces in indentation.
*/
@@ -392,18 +374,14 @@ public class OutputFormat implements Cloneable {
}
/**
- *
* Whether or not to use the XHTML standard: like HTML but passes an XML
* parser with real, closed tags. Also, XHTML CDATA sections will be output
* with the CDATA delimiters: ( " <![CDATA[ " and "
* ]]> " ) otherwise, the class HTMLWriter will output the
* CDATA text, but not the delimiters.
- *
- *
- *
+ *
* Default is false
- *
- *
+ *
* @return DOCUMENT ME!
*/
public boolean isXHTML() {
@@ -411,20 +389,16 @@ public class OutputFormat implements Cloneable {
}
/**
- *
* This will set whether or not to use the XHTML standard: like HTML but
* passes an XML parser with real, closed tags. Also, XHTML CDATA sections
* will be output with the CDATA delimiters: ( " <[CDATA[
* " and " ]]< ) otherwise, the class HTMLWriter
* will output the CDATA text, but not the delimiters.
- *
- *
- *
+ *
* Default: false
- *
- *
+ *
* @param xhtml
- * boolean true=>conform to XHTML, false=>conform
+ * boolean true → conform to XHTML, false → conform
* to HTML, can have unclosed tags, etc.
*/
public void setXHTML(boolean xhtml) {
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/PruningElementStack.java b/fine-org-dom4j/src/main/java/org/dom4j/io/PruningElementStack.java
index f53a28302..5d8ce416e 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/PruningElementStack.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/PruningElementStack.java
@@ -20,7 +20,7 @@ import org.dom4j.ElementHandler;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.11 $
*/
class PruningElementStack extends ElementStack {
/** ElementHandler to call when pruning occurs */
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/SAXContentHandler.java b/fine-org-dom4j/src/main/java/org/dom4j/io/SAXContentHandler.java
index 0685727fb..cf40de5a7 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/SAXContentHandler.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/SAXContentHandler.java
@@ -21,10 +21,7 @@ import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.Namespace;
import org.dom4j.QName;
-import org.dom4j.dtd.AttributeDecl;
-import org.dom4j.dtd.ElementDecl;
-import org.dom4j.dtd.ExternalEntityDecl;
-import org.dom4j.dtd.InternalEntityDecl;
+import org.dom4j.dtd.*;
import org.dom4j.tree.AbstractElement;
import org.dom4j.tree.NamespaceStack;
@@ -37,6 +34,7 @@ import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.ext.LexicalHandler;
+import org.xml.sax.ext.Locator2;
import org.xml.sax.helpers.DefaultHandler;
/**
@@ -45,7 +43,7 @@ import org.xml.sax.helpers.DefaultHandler;
*
*
* @author James Strachan
- * @version $Revision$
+ * @version $Revision: 1.61 $
*/
public class SAXContentHandler extends DefaultHandler implements
LexicalHandler, DeclHandler, DTDHandler {
@@ -82,17 +80,11 @@ public class SAXContentHandler extends DefaultHandler implements
*/
private StringBuffer cdataText;
- /** namespaces that are available for use */
- private Map availableNamespaceMap = new HashMap();
-
- /** declared namespaces that are not yet available for use */
- private List declaredNamespaceList = new ArrayList();
-
/** internal DTD declarations */
- private List internalDTDDeclarations;
+ private List internalDTDDeclarations;
/** external DTD declarations */
- private List externalDTDDeclarations;
+ private List externalDTDDeclarations;
/** The number of namespaces that are declared in the current scope */
private int declaredNamespaceIndex;
@@ -844,17 +836,8 @@ public class SAXContentHandler extends DefaultHandler implements
return null;
}
- // use reflection to avoid dependency on Locator2
- // or other locator implemenations.
- try {
- Method m = locator.getClass().getMethod("getEncoding",
- new Class[] {});
-
- if (m != null) {
- return (String) m.invoke(locator, null);
- }
- } catch (Exception e) {
- // do nothing
+ if (locator instanceof Locator2) {
+ return ((Locator2) locator).getEncoding();
}
// couldn't determine encoding, returning null...
@@ -941,9 +924,9 @@ public class SAXContentHandler extends DefaultHandler implements
* @param declaration
* DOCUMENT ME!
*/
- protected void addDTDDeclaration(Object declaration) {
+ protected void addDTDDeclaration(Decl declaration) {
if (internalDTDDeclarations == null) {
- internalDTDDeclarations = new ArrayList();
+ internalDTDDeclarations = new ArrayList();
}
internalDTDDeclarations.add(declaration);
@@ -955,9 +938,9 @@ public class SAXContentHandler extends DefaultHandler implements
* @param declaration
* DOCUMENT ME!
*/
- protected void addExternalDTDDeclaration(Object declaration) {
+ protected void addExternalDTDDeclaration(Decl declaration) {
if (externalDTDDeclarations == null) {
- externalDTDDeclarations = new ArrayList();
+ externalDTDDeclarations = new ArrayList();
}
externalDTDDeclarations.add(declaration);
diff --git a/fine-org-dom4j/src/main/java/org/dom4j/io/SAXEventRecorder.java b/fine-org-dom4j/src/main/java/org/dom4j/io/SAXEventRecorder.java
index 2f791c34d..192a3e8aa 100644
--- a/fine-org-dom4j/src/main/java/org/dom4j/io/SAXEventRecorder.java
+++ b/fine-org-dom4j/src/main/java/org/dom4j/io/SAXEventRecorder.java
@@ -67,9 +67,9 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
private static final byte NULL = 2;
- private List events = new ArrayList();
+ private List events = new ArrayList();
- private Map prefixMappings = new HashMap();
+ private Map> prefixMappings = new HashMap>();
private static final String XMLNS = "xmlns";
@@ -79,11 +79,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
}
public void replay(ContentHandler handler) throws SAXException {
- SAXEvent saxEvent;
- Iterator itr = events.iterator();
-
- while (itr.hasNext()) {
- saxEvent = (SAXEvent) itr.next();
+ for (SAXEvent saxEvent : events) {
switch (saxEvent.event) {
// replay to ContentHandler
@@ -117,13 +113,10 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
case SAXEvent.START_ELEMENT:
AttributesImpl attributes = new AttributesImpl();
- List attParmList = (List) saxEvent.getParm(3);
+ List attParmList = (List) saxEvent.getParm(3);
if (attParmList != null) {
- Iterator attsItr = attParmList.iterator();
-
- while (attsItr.hasNext()) {
- String[] attParms = (String[]) attsItr.next();
+ for (String[] attParms : attParmList) {
attributes.addAttribute(attParms[0], attParms[1],
attParms[2], attParms[3], attParms[4]);
}
@@ -145,8 +138,8 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
case SAXEvent.CHARACTERS:
char[] chars = (char[]) saxEvent.getParm(0);
- int start = ((Integer) saxEvent.getParm(1)).intValue();
- int end = ((Integer) saxEvent.getParm(2)).intValue();
+ int start = (Integer) saxEvent.getParm(1);
+ int end = (Integer) saxEvent.getParm(2);
handler.characters(chars, start, end);
break;
@@ -154,7 +147,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
// replay to LexicalHandler
case SAXEvent.START_DTD:
((LexicalHandler) handler).startDTD((String) saxEvent
- .getParm(0), (String) saxEvent.getParm(1),
+ .getParm(0), (String) saxEvent.getParm(1),
(String) saxEvent.getParm(2));
break;
@@ -189,8 +182,8 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
case SAXEvent.COMMENT:
char[] cchars = (char[]) saxEvent.getParm(0);
- int cstart = ((Integer) saxEvent.getParm(1)).intValue();
- int cend = ((Integer) saxEvent.getParm(2)).intValue();
+ int cstart = (Integer) saxEvent.getParm(1);
+ int cend = (Integer) saxEvent.getParm(2);
((LexicalHandler) handler).comment(cchars, cstart, cend);
break;
@@ -204,7 +197,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
case SAXEvent.ATTRIBUTE_DECL:
((DeclHandler) handler).attributeDecl((String) saxEvent
- .getParm(0), (String) saxEvent.getParm(1),
+ .getParm(0), (String) saxEvent.getParm(1),
(String) saxEvent.getParm(2), (String) saxEvent
.getParm(3), (String) saxEvent.getParm(4));
@@ -272,7 +265,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
saxEvent.addParm(localName);
saxEvent.addParm(qualifiedName);
- QName qName = null;
+ QName qName;
if (namespaceURI != null) {
qName = new QName(localName, Namespace.get(namespaceURI));
} else {
@@ -280,8 +273,8 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
}
if ((attributes != null) && (attributes.getLength() > 0)) {
- List attParmList = new ArrayList(attributes.getLength());
- String[] attParms = null;
+ List attParmList = new ArrayList(attributes.getLength());
+ String[] attParms;
for (int i = 0; i < attributes.getLength(); i++) {
@@ -292,7 +285,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
// if SAXWriter is writing a DOMDocument, namespace
// decls are treated as attributes. record a start
// prefix mapping event
- String prefix = null;
+ String prefix;
if (attLocalName.length() > 5) {
prefix = attLocalName.substring(6);
} else {
@@ -307,9 +300,9 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
// 'register' the prefix so that we can generate
// an end prefix mapping event within endElement
- List prefixes = (List) prefixMappings.get(qName);
+ List prefixes = prefixMappings.get(qName);
if (prefixes == null) {
- prefixes = new ArrayList();
+ prefixes = new ArrayList();
prefixMappings.put(qName, prefixes);
}
prefixes.add(prefix);
@@ -346,20 +339,19 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
// check to see if a we issued a start prefix mapping event
// for DOMDocument namespace decls
- QName elementName = null;
+ QName elementName;
if (namespaceURI != null) {
elementName = new QName(localName, Namespace.get(namespaceURI));
} else {
elementName = new QName(localName);
}
- List prefixes = (List) prefixMappings.get(elementName);
+ List prefixes = prefixMappings.get(elementName);
if (prefixes != null) {
- Iterator itr = prefixes.iterator();
- while (itr.hasNext()) {
- SAXEvent prefixEvent =
+ for (String prefixe : prefixes) {
+ SAXEvent prefixEvent =
new SAXEvent(SAXEvent.END_PREFIX_MAPPING);
- prefixEvent.addParm(itr.next());
+ prefixEvent.addParm(prefixe);
events.add(prefixEvent);
}
}
@@ -369,8 +361,8 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
public void characters(char[] ch, int start, int end) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.CHARACTERS);
saxEvent.addParm(ch);
- saxEvent.addParm(new Integer(start));
- saxEvent.addParm(new Integer(end));
+ saxEvent.addParm(start);
+ saxEvent.addParm(end);
events.add(saxEvent);
}
@@ -415,8 +407,8 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
public void comment(char[] ch, int start, int end) throws SAXException {
SAXEvent saxEvent = new SAXEvent(SAXEvent.COMMENT);
saxEvent.addParm(ch);
- saxEvent.addParm(new Integer(start));
- saxEvent.addParm(new Integer(end));
+ saxEvent.addParm(start);
+ saxEvent.addParm(end);
events.add(saxEvent);
}
@@ -469,7 +461,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
public void readExternal(ObjectInput in) throws ClassNotFoundException,
IOException {
if (in.readByte() != NULL) {
- events = (List) in.readObject();
+ events = (List) in.readObject();
}
}
@@ -518,7 +510,7 @@ public class SAXEventRecorder extends DefaultHandler implements LexicalHandler,
protected byte event;
- protected List parms;
+ protected List