You are viewing a plain text version of this content. The canonical link for it is here.
Posted to cvs@cocoon.apache.org by ha...@apache.org on 2002/12/16 11:01:12 UTC
cvs commit: xml-cocoon2/src/java/org/apache/cocoon/xml/dom DocumentWrapper.java DOMUtil.java
haul 2002/12/16 02:01:12
Modified: src/java/org/apache/cocoon/xml/dom DOMUtil.java
Added: src/java/org/apache/cocoon/xml/dom DocumentWrapper.java
Log:
<action dev="CH" type="add">
Wrapper for org.w3c.dom.Document that implements XMLizable and provides
a useful toString() method.
</action>
Revision Changes Path
1.6 +134 -1 xml-cocoon2/src/java/org/apache/cocoon/xml/dom/DOMUtil.java
Index: DOMUtil.java
===================================================================
RCS file: /home/cvs/xml-cocoon2/src/java/org/apache/cocoon/xml/dom/DOMUtil.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- DOMUtil.java 27 Sep 2002 09:05:18 -0000 1.5
+++ DOMUtil.java 16 Dec 2002 10:01:11 -0000 1.6
@@ -1115,4 +1115,137 @@
}
}
+ /**
+ * Create a string representation of a org.w3c.dom.Node and any
+ * (most) subtypes.
+ * @param node a <code>org.w3c.dom.Node</code> value
+ * @return a <code>String</code> value
+ */
+ public static String node2String(Node node) {
+ return node2StringBuffer(node).toString();
+ }
+
+ /**
+ * Create a string representation of a org.w3c.dom.Node and any
+ * (most) subtypes.
+ * @param node a <code>org.w3c.dom.Node</code> value
+ * @param pretty a <code>boolean</code> value whether to format the XML
+ * @return a <code>String</code> value
+ */
+ public static String node2String(Node node, boolean pretty) {
+ return node2StringBuffer(node, pretty, "").toString();
+ }
+
+ /**
+ * Create a string representation of a org.w3c.dom.Node and any
+ * (most) subtypes.
+ * @param node a <code>org.w3c.dom.Node</code> value
+ * @return a <code>StringBuffer</code> value
+ */
+ public static StringBuffer node2StringBuffer(Node node) {
+ return node2StringBuffer(node, false, "");
+ }
+
+ /**
+ * Create a string representation of a org.w3c.dom.Node and any
+ * (most) subtypes.
+ * @param node a <code>org.w3c.dom.Node</code> value
+ * @param pretty a <code>boolean</code> value whether to format the XML
+ * @param indent a <code>String</code> value containing spaces as
+ * initial indent, if null defaults to empty string.
+ * @return a <code>StringBuffer</code> value
+ */
+ public static StringBuffer node2StringBuffer(Node node, boolean pretty, String indent) {
+
+ String newIndent = null;
+ if (pretty) newIndent = (indent != null ? indent+" " : "");
+ if (node == null) return new StringBuffer();
+ NodeList children = null;
+
+ StringBuffer sb = new StringBuffer();
+ switch (node.getNodeType()) {
+ case Node.ELEMENT_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ sb.append('<').append(node.getNodeName());
+ NamedNodeMap attributes = node.getAttributes();
+ for (int i = 0; i < attributes.getLength(); i++) {
+ Node curr = attributes.item(i);
+ sb.append(' ').append(curr.getNodeName());
+ sb.append("=\"").append(curr.getNodeValue()).append('"');
+ }
+ if (node.hasChildNodes()) {
+ sb.append('>');
+ children = node.getChildNodes();
+ for(int i=0; i < children.getLength(); i++) {
+ sb.append(node2StringBuffer(children.item(i),pretty,newIndent));
+ }
+ if (pretty) sb.append("\n").append(indent);
+ sb.append("</").append(node.getNodeName()).append(">");
+ } else {
+ sb.append("/>");
+ }
+ break;
+ case Node.TEXT_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ sb.append(node.getNodeValue());
+ break;
+ case Node.DOCUMENT_NODE:
+ sb.append("<xml version=\"1.0\">");
+ if (node.hasChildNodes()) {
+ children = node.getChildNodes();
+ for(int i=0; i < children.getLength(); i++) {
+ sb.append(node2StringBuffer(children.item(i),pretty,newIndent));
+ }
+ }
+ //sb.append(node2StringBuffer(((Document)node).getDocumentElement(),pretty,newIndent));
+ break;
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ if (node.hasChildNodes()) {
+ children = node.getChildNodes();
+ for(int i=0; i < children.getLength(); i++) {
+ sb.append(node2StringBuffer(children.item(i),pretty,newIndent));
+ }
+ }
+ break;
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ sb.append("<?").append(node.getNodeName()).append(' ')
+ .append(node.getNodeValue()).append("?>");
+ break;
+ case Node.DOCUMENT_TYPE_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ DocumentType dt = (DocumentType) node;
+ sb.append("<!DOCTYPE ").append(dt.getName());
+ if (dt.getPublicId() != null) {
+ sb.append(" PUBLIC \"").append(dt.getPublicId()).append('"');
+ } else {
+ sb.append(" SYSTEM ");
+ }
+ sb.append('"').append(dt.getSystemId()).append("\">");
+ break;
+ case Node.CDATA_SECTION_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ sb.append("<![CDATA[").append(node.getNodeValue()).append("]]>");
+ break;
+ case Node.COMMENT_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ sb.append("<!--").append(node.getNodeValue()).append("-->");
+ break;
+ case Node.NOTATION_NODE:
+ if (pretty) sb.append("\n").append(indent);
+ Notation note = (Notation) node;
+ sb.append("<!NOTATION").append(note.getNodeName());
+ if (note.getPublicId() != null) {
+ sb.append(" PUBLIC \"").append(note.getPublicId()).append('"');
+ } else {
+ sb.append(" SYSTEM ");
+ }
+ sb.append('"').append(note.getSystemId()).append("\">");
+ break;
+ default:
+ // skip unknown node types
+ }
+ return sb;
+ }
+
}
1.1 xml-cocoon2/src/java/org/apache/cocoon/xml/dom/DocumentWrapper.java
Index: DocumentWrapper.java
===================================================================
/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2002 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
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 end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Apache Cocoon" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
apache@apache.org.
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``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 THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, 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.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
Stefano Mazzocchi <st...@apache.org>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.cocoon.xml.dom;
import org.apache.avalon.excalibur.xml.XMLizable;
import org.apache.cocoon.ProcessingException;
import org.w3c.dom.*;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
/**
* Wraps an org.w3c.dom.Document and offers additional interfaces
* like XMLizable and a toString() method.
*
* @author <a href="mailto:haul@apache.org">Christian Haul</a>
* @version CVS $Id: DocumentWrapper.java,v 1.1 2002/12/16 10:01:11 haul Exp $
*/
public class DocumentWrapper implements org.w3c.dom.Document, XMLizable, org.apache.cocoon.xml.XMLizable {
Document document = null;
/** Creates a new instance of DocmentWrapper */
public DocumentWrapper(Document doc) {
this.document = doc;
}
/**
* Generates SAX events representing the object's state.<br/>
* <b>NOTE</b> : if the implementation can produce lexical events,
* care should be taken that <code>handler</code> can actually be
* a {@link org.apache.cocoon.xml.XMLConsumer} that accepts such
* events.
*/
public void toSAX(org.xml.sax.ContentHandler handler) throws SAXException {
DOMStreamer ds = new DOMStreamer(handler);
ds.stream(this.document.getDocumentElement());
}
public String toString() {
return DOMUtil.node2String(this.document).toString();
}
/** Adds the node <code>newChild</code> to the end of the list of children
* of this node. If the <code>newChild</code> is already in the tree, it
* is first removed.
* @param newChild The node to add.If it is a
* <code>DocumentFragment</code> object, the entire contents of the
* document fragment are moved into the child list of this node
* @return The node added.
* @exception DOMException
* HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to append is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
* if the previous parent of the node being inserted is readonly.
*
*/
public Node appendChild(Node newChild) throws DOMException {
return this.document.appendChild(newChild);
}
/** Returns a duplicate of this node, i.e., serves as a generic copy
* constructor for nodes. The duplicate node has no parent; (
* <code>parentNode</code> is <code>null</code>.).
* <br>Cloning an <code>Element</code> copies all attributes and their
* values, including those generated by the XML processor to represent
* defaulted attributes, but this method does not copy any text it
* contains unless it is a deep clone, since the text is contained in a
* child <code>Text</code> node. Cloning an <code>Attribute</code>
* directly, as opposed to be cloned as part of an <code>Element</code>
* cloning operation, returns a specified attribute (
* <code>specified</code> is <code>true</code>). Cloning any other type
* of node simply returns a copy of this node.
* <br>Note that cloning an immutable subtree results in a mutable copy,
* but the children of an <code>EntityReference</code> clone are readonly
* . In addition, clones of unspecified <code>Attr</code> nodes are
* specified. And, cloning <code>Document</code>,
* <code>DocumentType</code>, <code>Entity</code>, and
* <code>Notation</code> nodes is implementation dependent.
* @param deep If <code>true</code>, recursively clone the subtree under
* the specified node; if <code>false</code>, clone only the node
* itself (and its attributes, if it is an <code>Element</code>).
* @return The duplicate node.
*
*/
public Node cloneNode(boolean deep) {
return this.document.cloneNode(deep);
}
/** Creates an <code>Attr</code> of the given name. Note that the
* <code>Attr</code> instance can then be set on an <code>Element</code>
* using the <code>setAttributeNode</code> method.
* <br>To create an attribute with a qualified name and namespace URI, use
* the <code>createAttributeNS</code> method.
* @param name The name of the attribute.
* @return A new <code>Attr</code> object with the <code>nodeName</code>
* attribute set to <code>name</code>, and <code>localName</code>,
* <code>prefix</code>, and <code>namespaceURI</code> set to
* <code>null</code>. The value of the attribute is the empty string.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*
*/
public Attr createAttribute(String name) throws DOMException {
return this.document.createAttribute(name);
}
/** Creates an attribute of the given qualified name and namespace URI.
* @param namespaceURI The namespace URI of the attribute to create.
* @param qualifiedName The qualified name of the attribute to
* instantiate.
* @return A new <code>Attr</code> object with the following attributes:
* <table border='1'>
* <tr>
* <th>
* Attribute</th>
* <th>Value</th>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.nodeName</code></td>
* <td valign='top' rowspan='1' colspan='1'>qualifiedName</td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'>
* <code>Node.namespaceURI</code></td>
* <td valign='top' rowspan='1' colspan='1'><code>namespaceURI</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'>
* <code>Node.prefix</code></td>
* <td valign='top' rowspan='1' colspan='1'>prefix, extracted from
* <code>qualifiedName</code>, or <code>null</code> if there is no
* prefix</td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.localName</code></td>
* <td valign='top' rowspan='1' colspan='1'>local name, extracted from
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Attr.name</code></td>
* <td valign='top' rowspan='1' colspan='1'>
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.nodeValue</code></td>
* <td valign='top' rowspan='1' colspan='1'>the empty
* string</td>
* </tr>
* </table>
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified qualified name
* contains an illegal character, per the XML 1.0 specification .
* <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
* malformed per the Namespaces in XML specification, if the
* <code>qualifiedName</code> has a prefix and the
* <code>namespaceURI</code> is <code>null</code>, if the
* <code>qualifiedName</code> has a prefix that is "xml" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/XML/1998/namespace", or if the
* <code>qualifiedName</code>, or its prefix, is "xmlns" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/2000/xmlns/".
* <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
* support the <code>"XML"</code> feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*
*/
public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException {
return this.document.createAttributeNS(namespaceURI, qualifiedName);
}
/** Creates a <code>CDATASection</code> node whose value is the specified
* string.
* @param data The data for the <code>CDATASection</code> contents.
* @return The new <code>CDATASection</code> object.
* @exception DOMException
* NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*
*/
public CDATASection createCDATASection(String data) throws DOMException {
return this.document.createCDATASection(data);
}
/** Creates a <code>Comment</code> node given the specified string.
* @param data The data for the node.
* @return The new <code>Comment</code> object.
*
*/
public Comment createComment(String data) {
return this.document.createComment(data);
}
/** Creates an empty <code>DocumentFragment</code> object.
* @return A new <code>DocumentFragment</code>.
*
*/
public DocumentFragment createDocumentFragment() {
return this.document.createDocumentFragment();
}
/** Creates an element of the type specified. Note that the instance
* returned implements the <code>Element</code> interface, so attributes
* can be specified directly on the returned object.
* <br>In addition, if there are known attributes with default values,
* <code>Attr</code> nodes representing them are automatically created
* and attached to the element.
* <br>To create an element with a qualified name and namespace URI, use
* the <code>createElementNS</code> method.
* @param tagName The name of the element type to instantiate. For XML,
* this is case-sensitive. For HTML, the <code>tagName</code>
* parameter may be provided in any case, but it must be mapped to the
* canonical uppercase form by the DOM implementation.
* @return A new <code>Element</code> object with the
* <code>nodeName</code> attribute set to <code>tagName</code>, and
* <code>localName</code>, <code>prefix</code>, and
* <code>namespaceURI</code> set to <code>null</code>.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*
*/
public Element createElement(String tagName) throws DOMException {
return this.document.createElement(tagName);
}
/** Creates an element of the given qualified name and namespace URI.
* @param namespaceURI The namespace URI of the element to create.
* @param qualifiedName The qualified name of the element type to
* instantiate.
* @return A new <code>Element</code> object with the following
* attributes:
* <table border='1'>
* <tr>
* <th>Attribute</th>
* <th>Value</th>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.nodeName</code></td>
* <td valign='top' rowspan='1' colspan='1'>
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.namespaceURI</code></td>
* <td valign='top' rowspan='1' colspan='1'>
* <code>namespaceURI</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.prefix</code></td>
* <td valign='top' rowspan='1' colspan='1'>prefix, extracted
* from <code>qualifiedName</code>, or <code>null</code> if there is
* no prefix</td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Node.localName</code></td>
* <td valign='top' rowspan='1' colspan='1'>local name, extracted from
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top' rowspan='1' colspan='1'><code>Element.tagName</code></td>
* <td valign='top' rowspan='1' colspan='1'>
* <code>qualifiedName</code></td>
* </tr>
* </table>
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified qualified name
* contains an illegal character, per the XML 1.0 specification .
* <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
* malformed per the Namespaces in XML specification, if the
* <code>qualifiedName</code> has a prefix and the
* <code>namespaceURI</code> is <code>null</code>, or if the
* <code>qualifiedName</code> has a prefix that is "xml" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/XML/1998/namespace" .
* <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
* support the <code>"XML"</code> feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*
*/
public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException {
return this.document.createElementNS(namespaceURI, qualifiedName);
}
/** Creates an <code>EntityReference</code> object. In addition, if the
* referenced entity is known, the child list of the
* <code>EntityReference</code> node is made the same as that of the
* corresponding <code>Entity</code> node.If any descendant of the
* <code>Entity</code> node has an unbound namespace prefix, the
* corresponding descendant of the created <code>EntityReference</code>
* node is also unbound; (its <code>namespaceURI</code> is
* <code>null</code>). The DOM Level 2 does not support any mechanism to
* resolve namespace prefixes.
* @param name The name of the entity to reference.
* @return The new <code>EntityReference</code> object.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*
*/
public EntityReference createEntityReference(String name) throws DOMException {
return this.document.createEntityReference(name);
}
/** Creates a <code>ProcessingInstruction</code> node given the specified
* name and data strings.
* @param target The target part of the processing instruction.
* @param data The data for the node.
* @return The new <code>ProcessingInstruction</code> object.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified target contains an
* illegal character.
* <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*
*/
public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException {
return this.document.createProcessingInstruction(target, data);
}
/** Creates a <code>Text</code> node given the specified string.
* @param data The data for the node.
* @return The new <code>Text</code> object.
*
*/
public Text createTextNode(String data) {
return this.document.createTextNode(data);
}
/** A <code>NamedNodeMap</code> containing the attributes of this node (if
* it is an <code>Element</code>) or <code>null</code> otherwise.
*
*/
public NamedNodeMap getAttributes() {
return this.document.getAttributes();
}
/** A <code>NodeList</code> that contains all children of this node. If
* there are no children, this is a <code>NodeList</code> containing no
* nodes.
*
*/
public NodeList getChildNodes() {
return this.document.getChildNodes();
}
/** The Document Type Declaration (see <code>DocumentType</code>)
* associated with this document. For HTML documents as well as XML
* documents without a document type declaration this returns
* <code>null</code>. The DOM Level 2 does not support editing the
* Document Type Declaration. <code>docType</code> cannot be altered in
* any way, including through the use of methods inherited from the
* <code>Node</code> interface, such as <code>insertNode</code> or
* <code>removeNode</code>.
*
*/
public DocumentType getDoctype() {
return this.document.getDoctype();
}
/** This is a convenience attribute that allows direct access to the child
* node that is the root element of the document. For HTML documents,
* this is the element with the tagName "HTML".
*
*/
public Element getDocumentElement() {
return this.document.getDocumentElement();
}
/** Returns the <code>Element</code> whose <code>ID</code> is given by
* <code>elementId</code>. If no such element exists, returns
* <code>null</code>. Behavior is not defined if more than one element
* has this <code>ID</code>. The DOM implementation must have
* information that says which attributes are of type ID. Attributes
* with the name "ID" are not of type ID unless so defined.
* Implementations that do not know whether attributes are of type ID or
* not are expected to return <code>null</code>.
* @param elementId The unique <code>id</code> value for an element.
* @return The matching element.
* @since DOM Level 2
*
*/
public Element getElementById(String elementId) {
return this.document.getElementById(elementId);
}
/** Returns a <code>NodeList</code> of all the <code>Elements</code> with a
* given tag name in the order in which they are encountered in a
* preorder traversal of the <code>Document</code> tree.
* @param tagname The name of the tag to match on. The special value "*"
* matches all tags.
* @return A new <code>NodeList</code> object containing all the matched
* <code>Elements</code>.
*
*/
public NodeList getElementsByTagName(String tagname) {
return this.document.getElementsByTagName(tagname);
}
/** Returns a <code>NodeList</code> of all the <code>Elements</code> with a
* given local name and namespace URI in the order in which they are
* encountered in a preorder traversal of the <code>Document</code> tree.
* @param namespaceURI The namespace URI of the elements to match on. The
* special value "*" matches all namespaces.
* @param localName The local name of the elements to match on. The
* special value "*" matches all local names.
* @return A new <code>NodeList</code> object containing all the matched
* <code>Elements</code>.
* @since DOM Level 2
*
*/
public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
return this.document.getElementsByTagNameNS(namespaceURI, localName);
}
/** The first child of this node. If there is no such node, this returns
* <code>null</code>.
*
*/
public Node getFirstChild() {
return this.document.getFirstChild();
}
/** The <code>DOMImplementation</code> object that handles this document. A
* DOM application may use objects from multiple implementations.
*
*/
public DOMImplementation getImplementation() {
return this.document.getImplementation();
}
/** The last child of this node. If there is no such node, this returns
* <code>null</code>.
*
*/
public Node getLastChild() {
return this.document.getLastChild();
}
/** Returns the local part of the qualified name of this node.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
* @since DOM Level 2
*
*/
public String getLocalName() {
return this.document.getLocalName();
}
/** The namespace URI of this node, or <code>null</code> if it is
* unspecified.
* <br>This is not a computed value that is the result of a namespace
* lookup based on an examination of the namespace declarations in
* scope. It is merely the namespace URI given at creation time.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.Per
* the Namespaces in XML Specification an attribute does not inherit
* its namespace from the element it is attached to. If an attribute is
* not explicitly given a namespace, it simply has no namespace.
* @since DOM Level 2
*
*/
public String getNamespaceURI() {
return this.document.getNamespaceURI();
}
/** The node immediately following this node. If there is no such node,
* this returns <code>null</code>.
*
*/
public Node getNextSibling() {
return this.document.getNextSibling();
}
/** The name of this node, depending on its type; see the table above.
*
*/
public String getNodeName() {
return this.document.getNodeName();
}
/** A code representing the type of the underlying object, as defined above.
*
*/
public short getNodeType() {
return this.document.getNodeType();
}
/** The value of this node, depending on its type; see the table above.
* When it is defined to be <code>null</code>, setting it has no effect.
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @exception DOMException
* DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a <code>DOMString</code> variable on the implementation
* platform.
*
*/
public String getNodeValue() throws DOMException {
return this.document.getNodeValue();
}
/** The <code>Document</code> object associated with this node. This is
* also the <code>Document</code> object used to create new nodes. When
* this node is a <code>Document</code> or a <code>DocumentType</code>
* which is not used with any <code>Document</code> yet, this is
* <code>null</code>.
* @version DOM Level 2
*
*/
public Document getOwnerDocument() {
return this.document.getOwnerDocument();
}
/** The parent of this node. All nodes, except <code>Attr</code>,
* <code>Document</code>, <code>DocumentFragment</code>,
* <code>Entity</code>, and <code>Notation</code> may have a parent.
* However, if a node has just been created and not yet added to the
* tree, or if it has been removed from the tree, this is
* <code>null</code>.
*
*/
public Node getParentNode() {
return this.document.getParentNode();
}
/** The namespace prefix of this node, or <code>null</code> if it is
* unspecified.
* <br>Note that setting this attribute, when permitted, changes the
* <code>nodeName</code> attribute, which holds the qualified name, as
* well as the <code>tagName</code> and <code>name</code> attributes of
* the <code>Element</code> and <code>Attr</code> interfaces, when
* applicable.
* <br>Note also that changing the prefix of an attribute that is known to
* have a default value, does not make a new attribute with the default
* value and the original prefix appear, since the
* <code>namespaceURI</code> and <code>localName</code> do not change.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
* illegal character, per the XML 1.0 specification .
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI</code> of this node is <code>null</code>, if the
* specified prefix is "xml" and the <code>namespaceURI</code> of this
* node is different from "http://www.w3.org/XML/1998/namespace", if
* this node is an attribute and the specified prefix is "xmlns" and
* the <code>namespaceURI</code> of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and
* the <code>qualifiedName</code> of this node is "xmlns" .
* @since DOM Level 2
*
*/
public String getPrefix() {
return this.document.getPrefix();
}
/** The node immediately preceding this node. If there is no such node,
* this returns <code>null</code>.
*
*/
public Node getPreviousSibling() {
return this.document.getPreviousSibling();
}
/** Returns whether this node (if it is an element) has any attributes.
* @return <code>true</code> if this node has any attributes,
* <code>false</code> otherwise.
* @since DOM Level 2
*
*/
public boolean hasAttributes() {
return this.document.hasAttributes();
}
/** Returns whether this node has any children.
* @return <code>true</code> if this node has any children,
* <code>false</code> otherwise.
*
*/
public boolean hasChildNodes() {
return this.document.hasChildNodes();
}
/** Imports a node from another document to this document. The returned
* node has no parent; (<code>parentNode</code> is <code>null</code>).
* The source node is not altered or removed from the original document;
* this method creates a new copy of the source node.
* <br>For all nodes, importing a node creates a node object owned by the
* importing document, with attribute values identical to the source
* node's <code>nodeName</code> and <code>nodeType</code>, plus the
* attributes related to namespaces (<code>prefix</code>,
* <code>localName</code>, and <code>namespaceURI</code>). As in the
* <code>cloneNode</code> operation on a <code>Node</code>, the source
* node is not altered.
* <br>Additional information is copied as appropriate to the
* <code>nodeType</code>, attempting to mirror the behavior expected if
* a fragment of XML or HTML source was copied from one document to
* another, recognizing that the two documents may have different DTDs
* in the XML case. The following list describes the specifics for each
* type of node.
* <dl>
* <dt>ATTRIBUTE_NODE</dt>
* <dd>The <code>ownerElement</code> attribute
* is set to <code>null</code> and the <code>specified</code> flag is
* set to <code>true</code> on the generated <code>Attr</code>. The
* descendants of the source <code>Attr</code> are recursively imported
* and the resulting nodes reassembled to form the corresponding subtree.
* Note that the <code>deep</code> parameter has no effect on
* <code>Attr</code> nodes; they always carry their children with them
* when imported.</dd>
* <dt>DOCUMENT_FRAGMENT_NODE</dt>
* <dd>If the <code>deep</code> option
* was set to <code>true</code>, the descendants of the source element
* are recursively imported and the resulting nodes reassembled to form
* the corresponding subtree. Otherwise, this simply generates an empty
* <code>DocumentFragment</code>.</dd>
* <dt>DOCUMENT_NODE</dt>
* <dd><code>Document</code>
* nodes cannot be imported.</dd>
* <dt>DOCUMENT_TYPE_NODE</dt>
* <dd><code>DocumentType</code>
* nodes cannot be imported.</dd>
* <dt>ELEMENT_NODE</dt>
* <dd>Specified attribute nodes of the
* source element are imported, and the generated <code>Attr</code>
* nodes are attached to the generated <code>Element</code>. Default
* attributes are not copied, though if the document being imported into
* defines default attributes for this element name, those are assigned.
* If the <code>importNode</code> <code>deep</code> parameter was set to
* <code>true</code>, the descendants of the source element are
* recursively imported and the resulting nodes reassembled to form the
* corresponding subtree.</dd>
* <dt>ENTITY_NODE</dt>
* <dd><code>Entity</code> nodes can be
* imported, however in the current release of the DOM the
* <code>DocumentType</code> is readonly. Ability to add these imported
* nodes to a <code>DocumentType</code> will be considered for addition
* to a future release of the DOM.On import, the <code>publicId</code>,
* <code>systemId</code>, and <code>notationName</code> attributes are
* copied. If a <code>deep</code> import is requested, the descendants
* of the the source <code>Entity</code> are recursively imported and
* the resulting nodes reassembled to form the corresponding subtree.</dd>
* <dt>
* ENTITY_REFERENCE_NODE</dt>
* <dd>Only the <code>EntityReference</code> itself is
* copied, even if a <code>deep</code> import is requested, since the
* source and destination documents might have defined the entity
* differently. If the document being imported into provides a
* definition for this entity name, its value is assigned.</dd>
* <dt>NOTATION_NODE</dt>
* <dd>
* <code>Notation</code> nodes can be imported, however in the current
* release of the DOM the <code>DocumentType</code> is readonly. Ability
* to add these imported nodes to a <code>DocumentType</code> will be
* considered for addition to a future release of the DOM.On import, the
* <code>publicId</code> and <code>systemId</code> attributes are copied.
* Note that the <code>deep</code> parameter has no effect on
* <code>Notation</code> nodes since they never have any children.</dd>
* <dt>
* PROCESSING_INSTRUCTION_NODE</dt>
* <dd>The imported node copies its
* <code>target</code> and <code>data</code> values from those of the
* source node.</dd>
* <dt>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</dt>
* <dd>These three
* types of nodes inheriting from <code>CharacterData</code> copy their
* <code>data</code> and <code>length</code> attributes from those of
* the source node.</dd>
* </dl>
* @param importedNode The node to import.
* @param deep If <code>true</code>, recursively import the subtree under
* the specified node; if <code>false</code>, import only the node
* itself, as explained above. This has no effect on <code>Attr</code>
* , <code>EntityReference</code>, and <code>Notation</code> nodes.
* @return The imported node that belongs to this <code>Document</code>.
* @exception DOMException
* NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
* supported.
* @since DOM Level 2
*
*/
public Node importNode(Node importedNode, boolean deep) throws DOMException {
return this.document.importNode(importedNode, deep);
}
/** Inserts the node <code>newChild</code> before the existing child node
* <code>refChild</code>. If <code>refChild</code> is <code>null</code>,
* insert <code>newChild</code> at the end of the list of children.
* <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
* all of its children are inserted, in the same order, before
* <code>refChild</code>. If the <code>newChild</code> is already in the
* tree, it is first removed.
* @param newChild The node to insert.
* @param refChild The reference node, i.e., the node before which the
* new node must be inserted.
* @return The node being inserted.
* @exception DOMException
* HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to insert is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
* if the parent of the node being inserted is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>refChild</code> is not a child of
* this node.
*
*/
public Node insertBefore(Node newChild, Node refChild) throws DOMException {
return this.document.insertBefore(newChild, refChild);
}
/** Tests whether the DOM implementation implements a specific feature and
* that feature is supported by this node.
* @param feature The name of the feature to test. This is the same name
* which can be passed to the method <code>hasFeature</code> on
* <code>DOMImplementation</code>.
* @param version This is the version number of the feature to test. In
* Level 2, version 1, this is the string "2.0". If the version is not
* specified, supporting any version of the feature will cause the
* method to return <code>true</code>.
* @return Returns <code>true</code> if the specified feature is
* supported on this node, <code>false</code> otherwise.
* @since DOM Level 2
*
*/
public boolean isSupported(String feature, String version) {
return this.document.isSupported(feature, version);
}
/** Puts all <code>Text</code> nodes in the full depth of the sub-tree
* underneath this <code>Node</code>, including attribute nodes, into a
* "normal" form where only structure (e.g., elements, comments,
* processing instructions, CDATA sections, and entity references)
* separates <code>Text</code> nodes, i.e., there are neither adjacent
* <code>Text</code> nodes nor empty <code>Text</code> 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
* <code>CDATASections</code>, the normalize operation alone may not be
* sufficient, since XPointers do not differentiate between
* <code>Text</code> nodes and <code>CDATASection</code> nodes.
* @version DOM Level 2
*
*/
public void normalize() {
this.document.normalize();
}
/** Removes the child node indicated by <code>oldChild</code> from the list
* of children, and returns it.
* @param oldChild The node being removed.
* @return The node removed.
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
* this node.
*
*/
public Node removeChild(Node oldChild) throws DOMException {
return this.document.removeChild(oldChild);
}
/** Replaces the child node <code>oldChild</code> with <code>newChild</code>
* in the list of children, and returns the <code>oldChild</code> node.
* <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
* <code>oldChild</code> is replaced by all of the
* <code>DocumentFragment</code> children, which are inserted in the
* same order. If the <code>newChild</code> is already in the tree, it
* is first removed.
* @param newChild The new node to put in the child list.
* @param oldChild The node being replaced in the list.
* @return The node replaced.
* @exception DOMException
* HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to put in is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of
* the new node is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
* this node.
*
*/
public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
return this.document.replaceChild(newChild, oldChild);
}
/** The value of this node, depending on its type; see the table above.
* When it is defined to be <code>null</code>, setting it has no effect.
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @exception DOMException
* DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a <code>DOMString</code> variable on the implementation
* platform.
*
*/
public void setNodeValue(String nodeValue) throws DOMException {
this.document.setNodeValue(nodeValue);
}
/** The namespace prefix of this node, or <code>null</code> if it is
* unspecified.
* <br>Note that setting this attribute, when permitted, changes the
* <code>nodeName</code> attribute, which holds the qualified name, as
* well as the <code>tagName</code> and <code>name</code> attributes of
* the <code>Element</code> and <code>Attr</code> interfaces, when
* applicable.
* <br>Note also that changing the prefix of an attribute that is known to
* have a default value, does not make a new attribute with the default
* value and the original prefix appear, since the
* <code>namespaceURI</code> and <code>localName</code> do not change.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
* illegal character, per the XML 1.0 specification .
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI</code> of this node is <code>null</code>, if the
* specified prefix is "xml" and the <code>namespaceURI</code> of this
* node is different from "http://www.w3.org/XML/1998/namespace", if
* this node is an attribute and the specified prefix is "xmlns" and
* the <code>namespaceURI</code> of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and
* the <code>qualifiedName</code> of this node is "xmlns" .
* @since DOM Level 2
*
*/
public void setPrefix(String prefix) throws DOMException {
this.document.setPrefix(prefix);
}
}
----------------------------------------------------------------------
In case of troubles, e-mail: webmaster@xml.apache.org
To unsubscribe, e-mail: cocoon-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: cocoon-cvs-help@xml.apache.org