## org.dom4j.tree
Class AbstractDocument

    java.lang.Object
      org.dom4j.tree.AbstractNode
          org.dom4j.tree.AbstractBranch
              org.dom4j.tree.AbstractDocument

All Implemented Interfaces:
  Branch, Cloneable, Document, Node, Serializable

Direct Known Subclasses:
  DefaultDocument

public abstract class AbstractDocument
extends AbstractBranch
implements Document

`AbstractDocument` is an abstract base class for tree implementors to use for implementation inheritence.

Version:
  $Revision: 1.33 $
Author:
  James Strachan
See Also:
  Serialized Form

Field Summary
`protected String` `encoding` The encoding of this document as stated in the XML declaration

Fields inherited from class org.dom4j.tree.AbstractBranch
`DEFAULT_CONTENT_LIST_SIZE`

Fields inherited from class org.dom4j.tree.AbstractNode
`NODE_TYPE_NAMES`

Fields inherited from interface org.dom4j.Node
`ANY_NODE, ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_REFERENCE_NODE, MAX_NODE_TYPE, NAMESPACE_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE, UNKNOWN_NODE`

Constructor Summary
`AbstractDocument()`

Method Summary
`void` `accept(Visitor visitor)` `accept` method is the `Visitor Pattern` method.
`void` `add(Element element)` Adds the given `Element` to this branch.
`Document` `addComment(String comment)` Adds a new `Comment` node with the given text to this branch.
`Element` `addElement(QName qName)` Adds a new `Element` node with the given `QName`to this branch and returns a reference to the new 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.
`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.
`Document` `addProcessingInstruction(String target, Map data)` Adds a processing instruction for the given target
`Document` `addProcessingInstruction(String target, String data)` Adds a processing instruction for the given target
`String` `asXML()` `asXML` returns the textual XML representation of this node.
`Node` `asXPathResult(Element parent)` `asXPathResult` returns a version of this node which is capable of being an XPath result.
`protected void` `checkAddElementAllowed(Element element)`
`protected void` `childAdded(Node node)` Called when a new child node has been added to me to allow any parent relationships to be created or events to be fired.
`protected void` `childRemoved(Node node)` Called when a child node has been removed to allow any parent relationships to be deleted or events to be fired.
`Document` `getDocument()` `getDocument` returns the `Document` that this `Node` is part of if this node supports the parent relationship.
`short` `getNodeType()` Returns the code according to the type of node.
`String` `getPath(Element context)` Returns the relative XPath expression which will return a node set containing the given node such as a/b/@c.
`String` `getStringValue()` Returns the XPath string-value of this node.
`String` `getUniquePath(Element context)` Returns the relative unique XPath expression from the given context which will return a nodeset of one node which is the current node.
`String` `getXMLEncoding()` Return the encoding of this document, as part of the XML declaration This is `null` when unspecified or when it is not known (such as when the Document was created in memory) or when the implementation does not support this operation.
`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.
`boolean` `remove(Element element)` Removes the given `Element` if the node is an immediate child of this branch.
`protected abstract void` `rootElementAdded(Element rootElement)` Called to set the root element variable
`void` `setRootElement(Element rootElement)` Sets the root element for this document
`void` `setXMLEncoding(String enc)` Sets the encoding of this document as it will appear in the XML declaration part of the document.
`String` `toString()`
`void` `write(Writer out)` `write` writes this node as the default XML notation for this node.

Methods inherited from class org.dom4j.tree.AbstractBranch

`add, add, add, addElement, addNode, addNode, appendContent, content, contentList, contentRemoved, createContentList, createContentList, createEmptyList, createResultList, createSingleResultList, elementByID, elementID, getContentAsStringValue, getContentAsText, getText, getTextTrim, hasContent, indexOf, invalidNodeTypeAddException, isReadOnly, node, nodeCount, nodeIterator, remove, remove, remove, removeNode, setProcessingInstructions`

Methods inherited from class org.dom4j.tree.AbstractNode
`clone, createPattern, createXPath, createXPathFilter, createXPathResult, detach, getDocumentFactory, getName, getNodeTypeName, getParent, getPath, getUniquePath, matches, numberValueOf, selectNodes, selectNodes, selectNodes, selectObject, selectSingleNode, setDocument, setName, setParent, setText, supportsParent, valueOf`

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.dom4j.Document
`addDocType, getDocType, getEntityResolver, getRootElement, setDocType, setEntityResolver`

Methods inherited from interface org.dom4j.Branch
`add, add, add, appendContent, clearContent, content, elementByID, indexOf, node, nodeCount, nodeIterator, processingInstruction, processingInstructions, processingInstructions, remove, remove, remove, removeProcessingInstruction, setContent, setProcessingInstructions`

Methods inherited from interface org.dom4j.Node
`clone, createXPath, detach, getName, getNodeTypeName, getParent, getPath, getText, getUniquePath, hasContent, isReadOnly, matches, numberValueOf, selectNodes, selectNodes, selectNodes, selectObject, selectSingleNode, setDocument, setName, setParent, setText, supportsParent, valueOf`

Field Detail

### encoding

    protected String encoding

  The encoding of this document as stated in the XML declaration

Constructor Detail

### AbstractDocument

    public AbstractDocument()

Method Detail

### getNodeType

    public short getNodeType()

  Description copied from interface: `Node`
  Returns the code according to the type of node. This makes processing nodes polymorphically much easier as the switch statement can be used instead of multiple if (instanceof) statements.

  Specified by:
    `getNodeType` in interface `Node`
  Overrides:
    `getNodeType` in class `AbstractNode`

### getPath

    public String getPath(Element context)

  Description copied from interface: `Node`
  Returns the relative XPath expression which will return a node set containing the given node such as a/b/@c. No indexing will be used to restrict the path if multiple elements with the same name occur on the path.

  Specified by:
    `getPath` in interface `Node`
  Parameters:
    `context` - is the parent context from which the relative path should start. If the context is null or the context is not an ancestor of this node then the path will be absolute and start from the document and so begin with the '/' character.
  Returns:
    the XPath expression relative to the given context which will return a nodeset containing at least this node.

### getUniquePath

    public String getUniquePath(Element context)

  Description copied from interface: `Node`

  Returns the relative unique XPath expression from the given context which will return a nodeset of one node which is the current node. This method will use the XPath index operator to restrict the path if multiple elements with the same name occur on the path.

  Specified by:
    `getUniquePath` in interface `Node`
  Parameters:
    `context` - is the parent context from which the path should start. If the context is null or the context is not an ancestor of this node then the path will start from the document and so begin with the '/' character.
  Returns:
    the XPath expression relative to the given context which will return a nodeset containing just this node.

### getDocument

    public Document getDocument()

  Description copied from interface: `Node`

  `getDocument` returns the `Document` that this `Node` is part of if this node supports the parent relationship.

  This method is an optional feature and may not be supported for all `Node` implementations.

  Specified by:
    `getDocument` in interface `Node`
  Overrides:
    `getDocument` in class `AbstractNode`

### getXMLEncoding

    public String getXMLEncoding()

  Description copied from interface: `Document`
  Return the encoding of this document, as part of the XML declaration This is `null` when unspecified or when it is not known (such as 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.

  Specified by:
    `getXMLEncoding` in interface `Document`
  Returns:
    The encoding of this document, as stated in the XML declaration, or `null` if unknown.

### getStringValue

    public String getStringValue()

  Description copied from interface: `Node`
  Returns the XPath string-value of this node. The behaviour of this method is defined in the XPath specification .

  Specified by:
    `getStringValue` in interface `Node`
  Overrides:
    `getStringValue` in class `AbstractNode`

### asXML

    public String asXML()

  Description copied from interface: `Node`

  `asXML` returns the textual XML representation of this node.

  Specified by:
    `asXML` in interface `Node`
  Returns:
    the XML representation of this node

### write

    public void write(Writer out)
               throws IOException

  Description copied from interface: `Node`

  `write` writes this node as the default XML notation for this node. If you wish to control the XML output (such as for pretty printing, changing the indentation policy etc.) then please use `XMLWriter` or its derivations.

  Specified by:
    `write` in interface `Node`
  Overrides:
    `write` in class `AbstractNode`
  Throws:
    `IOException`

### accept

    public void accept(Visitor visitor)

  `accept` method is the `Visitor Pattern` method.

  Specified by:
    `accept` in interface `Node`
  Parameters:
    `visitor` - `Visitor` is the visitor.

### toString

    public String toString()

### normalize

    public void normalize()

  Description copied from interface: `Branch`
  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.

  Specified by:
    `normalize` in interface `Branch`

### addComment

    public Document addComment(String comment)

  Description copied from interface: `Document`
  Adds a new `Comment` node with the given text to this branch.

  Specified by:
    `addComment` in interface `Document`
  Parameters:
    `comment` - is the text for the `Comment` node.
  Returns:
    this `Document` instance.

### addProcessingInstruction

    public Document addProcessingInstruction(String target,
                                             String data)

  Description copied from interface: `Document`
  Adds a processing instruction for the given target

  Specified by:
    `addProcessingInstruction` in interface `Document`
  Parameters:
    `target` - is the target of the processing instruction
    `data` - is the textual data (key/value pairs) of the processing instruction
  Returns:
    this `Document` instance.

### addProcessingInstruction

    public Document addProcessingInstruction(String target,
                                             Map data)

  Description copied from interface: `Document`
  Adds a processing instruction for the given target

  Specified by:
    `addProcessingInstruction` in interface `Document`
  Parameters:
    `target` - is the target of the processing instruction
    `data` - is a Map of the key / value pairs of the processing instruction
  Returns:
    this `Document` instance.

### addElement

    public Element addElement(String name)

  Description copied from interface: `Branch`
  Adds a new `Element` node with the given name to this branch and returns a reference to the new node.

  Specified by:
    `addElement` in interface `Branch`
  Overrides:
    `addElement` in class `AbstractBranch`

### addElement

    public Element addElement(String qualifiedName,
                              String namespaceURI)

  Description copied from interface: `Branch`
  Adds a new `Element` node with the given qualified name and namespace URI to this branch and returns a reference to the new node.

  Specified by:
    `addElement` in interface `Branch`
  Overrides:
    `addElement` in class `AbstractBranch`

### addElement

    public Element addElement(QName qName)

  Description copied from interface: `Branch`
  Adds a new `Element` node with the given `QName`to this branch and returns a reference to the new node.

  Specified by:
    `addElement` in interface `Branch`
  Overrides:
    `addElement` in class `AbstractBranch`

### setRootElement

    public void setRootElement(Element rootElement)

  Description copied from interface: `Document`
  Sets the root element for this document

  Specified by:
    `setRootElement` in interface `Document`
  Parameters:
    `rootElement` - the new root element for this document

### add

    public void add(Element element)

  Description copied from interface: `Branch`
  Adds the given `Element` to this branch. If the given node already has a parent defined then an `IllegalAddException` will be thrown.

  Specified by:
    `add` in interface `Branch`
  Overrides:
    `add` in class `AbstractBranch`

### remove

    public boolean remove(Element element)

  Description copied from interface: `Branch`
  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 `Node.detach()`method should be used instead.

  Specified by:
    `remove` in interface `Branch`
  Overrides:
    `remove` in class `AbstractBranch`

### asXPathResult

    public Node asXPathResult(Element parent)

  Description copied from interface: `Node`

  `asXPathResult` returns a version of this node which is capable of being an XPath result. The result of an XPath expression should always support the parent relationship, whether the original XML tree was singly or doubly linked. If the node does not support the parent relationship then a new node will be created which is linked to its parent and returned.

  Specified by:
    `asXPathResult` in interface `Node`
  Overrides:
    `asXPathResult` in class `AbstractNode`

### childAdded

    protected void childAdded(Node node)

  Description copied from class: `AbstractBranch`
  Called when a new child node has been added to me to allow any parent relationships to be created or events to be fired.

  Specified by:
    `childAdded` in class `AbstractBranch`
  Parameters:
    `node` - DOCUMENT ME!

### childRemoved

    protected void childRemoved(Node node)

  Description copied from class: `AbstractBranch`
  Called when a child node has been removed to allow any parent relationships to be deleted or events to be fired.

  Specified by:
    `childRemoved` in class `AbstractBranch`
  Parameters:
    `node` - DOCUMENT ME!

### checkAddElementAllowed

    protected void checkAddElementAllowed(Element element)

### rootElementAdded

    protected abstract void rootElementAdded(Element rootElement)

  Called to set the root element variable

  Parameters:
    `rootElement` - DOCUMENT ME!

### setXMLEncoding

    public void setXMLEncoding(String enc)

  Description copied from interface: `Document`
  Sets the encoding of this document as it will appear in the XML declaration part of the document.

  Specified by:
    `setXMLEncoding` in interface `Document`
  Parameters:
    `enc` - the encoding of the document

Copyright © 2001-2005 MetaStuff Ltd.. All Rights Reserved.