ParentNodeImpl (NetPhantom® 8.0 Java API Specification)

java.lang.Object
- org.openxml.dom.NodeImpl
- - org.openxml.dom.ParentNodeImpl

All Implemented Interfaces:
Cloneable, Node
Direct Known Subclasses:
DocumentImpl, ParentNSNodeImpl
```
public abstract class ParentNodeImpl
extends NodeImpl
implements Node, Cloneable
```
Implements a node that has child elements. To conserve memory space, nodes which do not support child elements are extended from NodeImpl, while nodes that support child elements are extended from ParentNodeImpl containing the additional member variables required to support child nodes.
This class is abstract. All derived classes must extend NodeImpl.getNodeType(). In addition, derived classes might wish to extend Node.cloneNode(boolean), equals(java.lang.Object) and Object.toString() and othe methods as necessary. Many methods cannot be extended.
Author:
Assaf Arkin
See Also:
Node, NodeImpl

Field Summary
- Fields inherited from class org.openxml.dom.NodeImpl
  ATTLIST_DECL_NODE, ELEMENT_DECL_NODE, PARAM_ENTITY_NODE
- Fields inherited from interface org.w3c.dom.Node
  ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_POSITION_CONTAINED_BY, DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_DISCONNECTED, DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, DOCUMENT_POSITION_PRECEDING, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE

Constructor Summary
Constructors
Modifier Constructor and Description
protected ParentNodeImpl(DocumentImpl owner, String name, String value)
Hidden constructor creates a new node.

Constructors
Modifier	Constructor and Description
`protected`	`ParentNodeImpl(DocumentImpl owner, String name, String value)` Hidden constructor creates a new node.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Node`	`appendChild(Node newChild)` Insert`newChild` as the last child of this parent.
`protected NodeImpl`	`castNewChild(Node newChild)` Checks whether`newChild` can be added to this node as a child, and if so, performs a necessary cast.
`protected NodeImpl`	`castOldChild(Node oldChild)` Checks whether`oldChild` is a direct child of this node, and if so, performs a necessary cast.
`protected void`	`cloneInto(NodeImpl into, boolean deep)` This clone method is called after a new node has been constructed to copy the contents of this node into the new one.
`protected org.w3c.dom.traversal.NodeIterator`	`createNodeIterator(boolean tree, int whatToShow, org.w3c.dom.traversal.NodeFilter nodeFilter)`
`boolean`	`equals(Object other)` Returns true if this node and`other` are identical by content but not context.
`NodeList`	`getChildNodes()` Returns a `NodeList` object that can be used to traverse this node's children.
`Node`	`getFirstChild()` Returns the first child of the node.
`Node`	`getLastChild()` Returns the last child of the node.
`boolean`	`hasChildNodes()` Return true if there are any childern to this node.
`Node`	`insertBefore(Node newChild, Node refChild)` Insert`newChild` in this parent, before the existing child`refChild`.
`void`	`normalize()`
`Node`	`removeChild(Node oldChild)` Remove`oldChild` from this parent.
`void`	`removeInnerIterator(InnerIterator iterator)`
`Node`	`replaceChild(Node newChild, Node oldChild)` Replace`oldChild` with`newChild`, adding the new child and removing the old one.

Methods inherited from class org.openxml.dom.NodeImpl
getAttributes, getLocalName, getNamespaceURI, getNextSibling, getNodeName, getNodeType, getNodeValue, getOwnerDocument, getParentNode, getPrefix, getPreviousSibling, isReadOnly, makeReadOnly, setNodeValue, setOwnerDocument, setPrefix, supports

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.w3c.dom.Node
cloneNode, compareDocumentPosition, getAttributes, getBaseURI, getFeature, getLocalName, getNamespaceURI, getNextSibling, getNodeName, getNodeType, getNodeValue, getOwnerDocument, getParentNode, getPrefix, getPreviousSibling, getTextContent, getUserData, hasAttributes, isDefaultNamespace, isEqualNode, isSameNode, isSupported, lookupNamespaceURI, lookupPrefix, setNodeValue, setPrefix, setTextContent, setUserData

- Constructor Detail
  - ParentNodeImpl
```
protected ParentNodeImpl(DocumentImpl owner,
                         String name,
                         String value)
                  throws DOMException
```
    Hidden constructor creates a new node. Only one constructor is supported, although cloning is also supported. Owner document must be supplied except for DocumentImpl or DocumentTypeImpl,
    IfcheckName is true, the supplied named is assumed to be a valid XML name token, one that can contain any Unicode letters and digits, must start with a letter, and may also contain hyphen, underscore, digit or colon.
    Parameters:
    owner - Document owner of this node, or null
    name - Name of node
    value - Initial value of node or null
    Throws:
    DOMException -INVALID_CHARACTER_ERR Node name cannot contain whitespace or non-printable characters
- Method Detail
  - getChildNodes
```
public final NodeList getChildNodes()
```
    Description copied from class: NodeImpl
    Returns a NodeList object that can be used to traverse this node's children. The node list is live, so every change to this node is reflected in it. If the node does not support children, returns an empty node list.
    Specified by:
    getChildNodes in interface Node
    Overrides:
    getChildNodes in class NodeImpl
    Returns:
    NodeList on this node
    See Also:
    NodeList
  - getFirstChild
```
public final Node getFirstChild()
```
    Description copied from class: NodeImpl
    Returns the first child of the node. If node has no children, returns null.
    Specified by:
    getFirstChild in interface Node
    Overrides:
    getFirstChild in class NodeImpl
    Returns:
    First child or null
  - getLastChild
```
public final Node getLastChild()
```
    Description copied from class: NodeImpl
    Returns the last child of the node. If node has no children, returns null.
    Specified by:
    getLastChild in interface Node
    Overrides:
    getLastChild in class NodeImpl
    Returns:
    Last child or null
  - hasChildNodes
```
public final boolean hasChildNodes()
```
    Description copied from class: NodeImpl
    Return true if there are any childern to this node. Less intensive than calling NodeImpl.getChildNodes().
    Specified by:
    hasChildNodes in interface Node
    Overrides:
    hasChildNodes in class NodeImpl
    Returns:
    True if node has any children
  - normalize
```
public void normalize()
```
    Specified by:
    normalize in interface Node
    Overrides:
    normalize in class NodeImpl
  - appendChild
```
public final Node appendChild(Node newChild)
```
    Description copied from class: NodeImpl
    InsertnewChild as the last child of this parent.
    IfnewChild is null,newChild is not a compatible type, or childern are not supported by this node type, an exception is thrown.
    newChild is removed from its original parent before adding to this parent. IfnewChild is a DocumentFragment, all its children are inserted one by one into this parent.
    Specified by:
    appendChild in interface Node
    Overrides:
    appendChild in class NodeImpl
    Parameters:
    newChild - The new child to add
    Returns:
    The newly inserted child
  - insertBefore
```
public final Node insertBefore(Node newChild,
                               Node refChild)
                        throws DOMException
```
    Description copied from class: NodeImpl
    InsertnewChild in this parent, before the existing childrefChild. IfrefChild is null, insertnewChild as the last child of this parent, akin to calling NodeImpl.appendChild(org.w3c.dom.Node).
    IfnewChild is null,newChild does not belong to this DOM,refChild is not a direct child of this node, or childern are not supported by this node type, an exception is thrown.
    newChild is removed from its original parent before adding to this parent. IfnewChild is a DocumentFragment, all its children are inserted one by one into this parent.
    Specified by:
    insertBefore in interface Node
    Overrides:
    insertBefore in class NodeImpl
    Parameters:
    newChild - The new child to add
    refChild - Insert new child before this child, or insert at the end if this child is null
    Returns:
    The newly inserted child
    Throws:
    DOMException -NO_MODIFICATION_ALLOWED_ERR Node is read-only and cannot be modified
  - removeChild
```
public final Node removeChild(Node oldChild)
                       throws DOMException
```
    Description copied from class: NodeImpl
    RemoveoldChild from this parent. IfoldChild is not a direct child of this parent, or childern are not supported by this node type, an exception is thrown.
    Specified by:
    removeChild in interface Node
    Overrides:
    removeChild in class NodeImpl
    Parameters:
    oldChild - The child to remove
    Returns:
    The removed child
    Throws:
    DOMException -NO_MODIFICATION_ALLOWED_ERR Node is read-only and cannot be modified
  - replaceChild
```
public final Node replaceChild(Node newChild,
                               Node oldChild)
                        throws DOMException
```
    Description copied from class: NodeImpl
    ReplaceoldChild withnewChild, adding the new child and removing the old one.
    IfnewChild does not belong to this DOM,oldChild is not a direct child of this parent, or childern are not supported by this node type, an exception is thrown.
    newChild is removed from its original parent before adding to this parent. IfnewChild is a DocumentFragment, all its children are inserted one by one into this parent.
    Specified by:
    replaceChild in interface Node
    Overrides:
    replaceChild in class NodeImpl
    Parameters:
    newChild - The new child to add
    oldChild - The old child to take away
    Returns:
    The old child
    Throws:
    DOMException -NO_MODIFICATION_ALLOWED_ERR Node is read-only and cannot be modified
  - castNewChild
```
protected NodeImpl castNewChild(Node newChild)
                         throws DOMException
```
    Checks whethernewChild can be added to this node as a child, and if so, performs a necessary cast.newChild cannot be null and must belong to this DOM. It is impossible to transfer nodes between different DOM implementations.
    The following rules govern the allowednewChild types:
    - Parent is an Attr,newChild must be either a Text or an EntityReference
    - Parent is a DocumentType,newChild must be either an Entity or a Notation.
    - Parnet is any other node type,newChild must be an Element, a CharacterData derived type, a DocumentFragment, an EntityReference or a ProcessingInstruction.
    Any deviation will throw an exception.
    Parameters:
    newChild - New child node
    Returns:
    newChild cast to type NodeImpl
    Throws:
    DOMException -HIERARCHY_REQUEST_ERRnewChild is null, does not belong to this DOM, or its node type is not supported for this parent
  - castOldChild
```
protected final NodeImpl castOldChild(Node oldChild)
                               throws DOMException
```
    Checks whetheroldChild is a direct child of this node, and if so, performs a necessary cast.oldChild cannot be null.
    Parameters:
    oldChild - Old child node
    Returns:
    oldChild cast to type NodeImpl
    Throws:
    DOMException -NOT_FOUND_ERRoldChild is null, or not a direct child of this node
  - createNodeIterator
```
protected org.w3c.dom.traversal.NodeIterator createNodeIterator(boolean tree,
                                                                int whatToShow,
                                                                org.w3c.dom.traversal.NodeFilter nodeFilter)
```
  - removeInnerIterator
```
public void removeInnerIterator(InnerIterator iterator)
```
  - cloneInto
```
protected void cloneInto(NodeImpl into,
                         boolean deep)
```
    Description copied from class: NodeImpl
    This clone method is called after a new node has been constructed to copy the contents of this node into the new one. It clones in contents but not in context, and guarantees that the cloned node will pass the equality test (see NodeImpl.equals(java.lang.Object)).
    into must be a valid node of the exact same class as this one.deep is true if deep cloning (includes all children nodes) is to be performed. Ifdeep is false, the clone might not pass the equality test.
    Derived classes override and call this method to add per-class variable copying. This method is called by Node.cloneNode(boolean) and the default Object.clone() method.
    Contents cloning duplicates the node's name and value, and its children. It does not duplicate it's context, that is, the node's parent or sibling. Initially a clone node has no parents or siblings. However, the node does belong to the same document, since all nodes must belong to some document. The cloned node is never read-only.
    Overrides:
    cloneInto in class NodeImpl
    Parameters:
    into - A node into which to duplicate this one
    deep - True if deep cloning is required
  - equals
```
public boolean equals(Object other)
```
    Description copied from class: NodeImpl
    Returns true if this node andother are identical by content but not context. Test by content but not context adheres to the following:
    - Both nodes must be of the same type, must have the same name and value (case sensitive) and for elements, the same tag name
    - For elements, both must have identical attribute list, although attributes may be specified/unspecified and in different orders
    - Both nodes must have no children, or must have the exact same sequence of children; children are tested for equality by calling NodeImpl.equals(java.lang.Object) on each pair
    - However, both nodes may reside in different documents, belong to different parents, have different siblings, different read-only flags, etc.
    It is guaranteed that the act of cloning a node will return a second node that will pass the test of equality.
    Note that for large document roots, the equality operation can be very expensive.
    Overrides:
    equals in class NodeImpl
    Parameters:
    other - The other node to test for equality
    Returns:
    True if both nodes are equal based on their content but not their context

Class ParentNodeImpl

Field Summary

Fields inherited from class org.openxml.dom.NodeImpl

Fields inherited from interface org.w3c.dom.Node

Constructor Summary

Method Summary

Methods inherited from class org.openxml.dom.NodeImpl

Methods inherited from class java.lang.Object

Methods inherited from interface org.w3c.dom.Node

Constructor Detail

ParentNodeImpl

Method Detail

getChildNodes

getFirstChild

getLastChild

hasChildNodes

normalize

appendChild

insertBefore

removeChild

replaceChild

castNewChild

castOldChild

createNodeIterator

removeInnerIterator

cloneInto

equals