## org.apache.axis.message
Class NodeImpl

    java.lang.Object
      org.apache.axis.message.NodeImpl

All Implemented Interfaces:
  java.lang.Cloneable, Node, org.w3c.dom.Node, java.io.Serializable

Direct Known Subclasses:
  MessageElement, Text

public class NodeImpl
extends java.lang.Object
implements org.w3c.dom.Node, Node, java.io.Serializable, java.lang.Cloneable

This is our implementation of the DOM node

See Also:
  Serialized Form

Field Summary
`protected boolean` `_isDirty`
`protected org.xml.sax.Attributes` `attributes`
`protected java.util.ArrayList` `children`
`protected org.w3c.dom.Document` `document`
`protected static org.apache.commons.logging.Log` `log`
`protected java.lang.String` `name`
`protected java.lang.String` `namespaceURI`
`protected NodeImpl` `parent`
`protected java.lang.String` `prefix`
`protected org.w3c.dom.CharacterData` `textRep`

Fields inherited from interface org.w3c.dom.Node
`ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE`

Constructor Summary
`NodeImpl()` empty constructor
`NodeImpl(org.w3c.dom.CharacterData text)` constructor which adopts the name and NS of the char data, and its text

Method Summary
`org.w3c.dom.Node` `appendChild(org.w3c.dom.Node newChild)` Adds the node `newChild` to the end of the list of children of this node.
`org.w3c.dom.Node` `cloneNode(boolean deep)` Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes.

`protected org.w3c.dom.NamedNodeMap`

`convertAttrSAXtoDOM(org.xml.sax.Attributes saxAttr)`
The internal representation of Attributes cannot help being changed It is because Attribute is not immutible Type, so if we keep out value and just return it in another form, the application may chnae it, which we cannot detect without some kind back track method (call back notifying the chnage.) I am not sure which approach is better.

`void` `detachNode()` Removes this `Node` object from the tree.
`org.w3c.dom.NamedNodeMap` `getAttributes()` A `NamedNodeMap` containing the attributes of this node (if it is an `Element`) or `null` otherwise.
`org.w3c.dom.NodeList` `getChildNodes()` A `NodeList` that contains all children of this node.
`org.w3c.dom.Node` `getFirstChild()` The first child of this node.
`org.w3c.dom.Node` `getLastChild()` The last child of this node.
`java.lang.String` `getLocalName()` Returns the local part of the qualified name of this node.
`java.lang.String` `getNamespaceURI()` The namespace URI of this node, or `null` if it is unspecified.
`org.w3c.dom.Node` `getNextSibling()` The node immediately following this node.
`java.lang.String` `getNodeName()` The name of this node, depending on its type; see the table above.
`short` `getNodeType()` A code representing the type of the underlying object, as defined above.
`java.lang.String` `getNodeValue()` The value of this node, depending on its type; see the table above.
`org.w3c.dom.Document` `getOwnerDocument()` The `Document` object associated with this node.
`protected NodeImpl` `getParent()` get the parent node
`SOAPElement` `getParentElement()` Returns the parent element of this `Node` object.
`org.w3c.dom.Node` `getParentNode()` The parent of this node.
`java.lang.String` `getPrefix()` The namespace prefix of this node, or `null` if it is unspecified.
`org.w3c.dom.Node` `getPreviousSibling()` The node immediately preceding this node.
`java.lang.String` `getValue()` Returns the the value of the immediate child of this `Node` object if a child exists and its value is text.
`boolean` `hasAttributes()` Returns whether this node (if it is an element) has any attributes.
`boolean` `hasChildNodes()` Returns whether this node has any children.
`protected void` `initializeChildren()` Initialize the children array
`org.w3c.dom.Node` `insertBefore(org.w3c.dom.Node newChild, org.w3c.dom.Node refChild)` Inserts the node `newChild` before the existing child node `refChild`.
`boolean` `isDirty()` get the dirty bit
`boolean` `isSupported(java.lang.String feature, java.lang.String version)` Tests whether the DOM implementation implements a specific feature and that feature is supported by this node.
`protected org.xml.sax.helpers.AttributesImpl` `makeAttributesEditable()` make the attributes editable
`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.
`void` `output(SerializationContext context)` print the contents of this node
`void` `recycleNode()` Notifies the implementation that this `Node` object is no longer being used by the application and that the implementation is free to reuse this object for nodes that may be created later.
`org.w3c.dom.Node` `removeChild(org.w3c.dom.Node oldChild)` Removes the child node indicated by `oldChild` from the list of children, and returns it.
`org.w3c.dom.Node` `replaceChild(org.w3c.dom.Node newChild, org.w3c.dom.Node oldChild)` Replaces the child node `oldChild` with `newChild` in the list of children, and returns the `oldChild` node.
`void` `reset()`
`void` `setDirty()`
`void` `setDirty(boolean dirty)` set the dirty bit.
`void` `setNodeValue(java.lang.String nodeValue)` The value of this node, depending on its type; see the table above.
`void` `setOwnerDocument(org.w3c.dom.Document doc)` Set the owner document
`protected void` `setParent(NodeImpl parent)` Set the parent node and invoke appendChild(this) to add this node to the parent's list of children.
`void` `setParentElement(SOAPElement parent)` Sets the parent of this `Node` object to the given `SOAPElement` object.
`void` `setPrefix(java.lang.String prefix)` The namespace prefix of this node, or `null` if it is unspecified.
`void` `setValue(java.lang.String value)` If this is a Text node then this method will set its value, otherwise it sets the value of the immediate (Text) child of this node.

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

Field Detail

### log

    protected static org.apache.commons.logging.Log log

### name

    protected java.lang.String name

### prefix

    protected java.lang.String prefix

### namespaceURI

    protected java.lang.String namespaceURI

### attributes

    protected transient org.xml.sax.Attributes attributes

### document

    protected org.w3c.dom.Document document

### parent

    protected NodeImpl parent

### children

    protected java.util.ArrayList children

### textRep

    protected org.w3c.dom.CharacterData textRep

### _isDirty

    protected boolean _isDirty

Constructor Detail

### NodeImpl

    public NodeImpl()

  empty constructor

### NodeImpl

    public NodeImpl(org.w3c.dom.CharacterData text)

  constructor which adopts the name and NS of the char data, and its text

Parameters:
  `text` -

Method Detail

### getNodeType

    public short getNodeType()

  A code representing the type of the underlying object, as defined above.

  Specified by:
    `getNodeType` in interface `org.w3c.dom.Node`

### normalize

    public 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.

  Specified by:
    `normalize` in interface `org.w3c.dom.Node`

### hasAttributes

    public boolean hasAttributes()

  Returns whether this node (if it is an element) has any attributes.

  Specified by:
    `hasAttributes` in interface `org.w3c.dom.Node`
  Returns:
    `true` if this node has any attributes, `false` otherwise.
  Since:
    DOM Level 2

### hasChildNodes

    public boolean hasChildNodes()

  Returns whether this node has any children.

  Specified by:
    `hasChildNodes` in interface `org.w3c.dom.Node`
  Returns:
    `true` if this node has any children, `false` otherwise.

### getLocalName

    public java.lang.String getLocalName()

  Returns the local part of the qualified name of this node.
  For nodes of any type other than `ELEMENT_NODE` and `ATTRIBUTE_NODE` and nodes created with a DOM Level 1 method, such as `createElement` from the `Document` interface, this is always `null`.

  Specified by:
    `getLocalName` in interface `org.w3c.dom.Node`
  Since:
    DOM Level 2

### getNamespaceURI

    public java.lang.String getNamespaceURI()

  The namespace URI of this node, or `null` if it is unspecified.
  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.
  For nodes of any type other than `ELEMENT_NODE` and `ATTRIBUTE_NODE` and nodes created with a DOM Level 1 method, such as `createElement` from the `Document` interface, this is always `null`.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.

  Specified by:
    `getNamespaceURI` in interface `org.w3c.dom.Node`
  Since:
    DOM Level 2

### getNodeName

    public java.lang.String getNodeName()

  The name of this node, depending on its type; see the table above.

  Specified by:
    `getNodeName` in interface `org.w3c.dom.Node`

### getNodeValue

    public java.lang.String getNodeValue()
                                  throws org.w3c.dom.DOMException

  The value of this node, depending on its type; see the table above. When it is defined to be `null`, setting it has no effect.

  Specified by:
    `getNodeValue` in interface `org.w3c.dom.Node`
  Throws:
    `org.w3c.dom.DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
    `org.w3c.dom.DOMException` - DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a `DOMString` variable on the implementation platform.

### getPrefix

    public java.lang.String getPrefix()

  The namespace prefix of this node, or `null` if it is unspecified.
  Note that setting this attribute, when permitted, changes the `nodeName` attribute, which holds the qualified name, as well as the `tagName` and `name` attributes of the `Element` and `Attr` interfaces, when applicable.
  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 `namespaceURI` and `localName` do not change.
  For nodes of any type other than `ELEMENT_NODE` and `ATTRIBUTE_NODE` and nodes created with a DOM Level 1 method, such as `createElement` from the `Document` interface, this is always `null`.

  Specified by:
    `getPrefix` in interface `org.w3c.dom.Node`
  Throws:
    `org.w3c.dom.DOMException` - INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character, per the XML 1.0 specification .
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NAMESPACE_ERR: Raised if the specified `prefix` is malformed per the Namespaces in XML specification, if the `namespaceURI` of this node is `null`, if the specified prefix is "xml" and the `namespaceURI` 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 `namespaceURI` of this node is different from " http://www.w3.org/2000/xmlns/", or if this node is an attribute and the `qualifiedName` of this node is "xmlns" .
  Since:
    DOM Level 2

### setNodeValue

    public void setNodeValue(java.lang.String nodeValue)
                      throws org.w3c.dom.DOMException

  The value of this node, depending on its type; see the table above. When it is defined to be `null`, setting it has no effect.

  Specified by:
    `setNodeValue` in interface `org.w3c.dom.Node`
  Throws:
    `org.w3c.dom.DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
    `org.w3c.dom.DOMException` - DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a `DOMString` variable on the implementation platform.

### setPrefix

    public void setPrefix(java.lang.String prefix)

  The namespace prefix of this node, or `null` if it is unspecified.
  Note that setting this attribute, when permitted, changes the `nodeName` attribute, which holds the qualified name, as well as the `tagName` and `name` attributes of the `Element` and `Attr` interfaces, when applicable.
  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 `namespaceURI` and `localName` do not change.
  For nodes of any type other than `ELEMENT_NODE` and `ATTRIBUTE_NODE` and nodes created with a DOM Level 1 method, such as `createElement` from the `Document` interface, this is always `null`.

  Specified by:
    `setPrefix` in interface `org.w3c.dom.Node`
  Throws:
    `org.w3c.dom.DOMException` - INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character, per the XML 1.0 specification .
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NAMESPACE_ERR: Raised if the specified `prefix` is malformed per the Namespaces in XML specification, if the `namespaceURI` of this node is `null`, if the specified prefix is "xml" and the `namespaceURI` 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 `namespaceURI` of this node is different from " http://www.w3.org/2000/xmlns/", or if this node is an attribute and the `qualifiedName` of this node is "xmlns" .
  Since:
    DOM Level 2

### setOwnerDocument

    public void setOwnerDocument(org.w3c.dom.Document doc)

  Set the owner document

  Parameters:
    `doc` -

### getOwnerDocument

    public org.w3c.dom.Document getOwnerDocument()

  The `Document` object associated with this node. This is also the `Document` object used to create new nodes. When this node is a `Document` or a `DocumentType` which is not used with any `Document` yet, this is `null`.

  Specified by:
    `getOwnerDocument` in interface `org.w3c.dom.Node`

### getAttributes

    public org.w3c.dom.NamedNodeMap getAttributes()

  A `NamedNodeMap` containing the attributes of this node (if it is an `Element`) or `null` otherwise.

  Specified by:
    `getAttributes` in interface `org.w3c.dom.Node`

### getFirstChild

    public org.w3c.dom.Node getFirstChild()

  The first child of this node. If there is no such node, this returns `null`.

  Specified by:
    `getFirstChild` in interface `org.w3c.dom.Node`

### getLastChild

    public org.w3c.dom.Node getLastChild()

  The last child of this node. If there is no such node, this returns `null`.

  Specified by:
    `getLastChild` in interface `org.w3c.dom.Node`

### getNextSibling

    public org.w3c.dom.Node getNextSibling()

  The node immediately following this node. If there is no such node, this returns `null`.

  Specified by:
    `getNextSibling` in interface `org.w3c.dom.Node`

### getParentNode

    public org.w3c.dom.Node getParentNode()

  The parent of this node. All nodes, except `Attr`, `Document`, `DocumentFragment`, `Entity`, and `Notation` 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 `null`.

  Specified by:
    `getParentNode` in interface `org.w3c.dom.Node`

### getPreviousSibling

    public org.w3c.dom.Node getPreviousSibling()

  The node immediately preceding this node. If there is no such node, this returns `null`.

  Specified by:
    `getPreviousSibling` in interface `org.w3c.dom.Node`

### cloneNode

    public org.w3c.dom.Node cloneNode(boolean deep)

  Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes. The duplicate node has no parent; ( `parentNode` is `null`.).
  Cloning an `Element` 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 `Text` node. Cloning an `Attribute` directly, as opposed to be cloned as part of an `Element` cloning operation, returns a specified attribute ( `specified` is `true`). Cloning any other type of node simply returns a copy of this node.
  Note that cloning an immutable subtree results in a mutable copy, but the children of an `EntityReference` clone are readonly . In addition, clones of unspecified `Attr` nodes are specified. And, cloning `Document`, `DocumentType`, `Entity`, and `Notation` nodes is implementation dependent.

  Specified by:
    `cloneNode` in interface `org.w3c.dom.Node`
  Parameters:
    `deep` - If `true`, recursively clone the subtree under the specified node; if `false`, clone only the node itself (and its attributes, if it is an `Element`).
  Returns:
    The duplicate node.

### getChildNodes

    public org.w3c.dom.NodeList getChildNodes()

  A `NodeList` that contains all children of this node. If there are no children, this is a `NodeList` containing no nodes.

  Specified by:
    `getChildNodes` in interface `org.w3c.dom.Node`

### isSupported

    public boolean isSupported(java.lang.String feature,
                               java.lang.String version)

  Tests whether the DOM implementation implements a specific feature and that feature is supported by this node.

  Specified by:
    `isSupported` in interface `org.w3c.dom.Node`
  Parameters:
    `feature` - The name of the feature to test. This is the same name which can be passed to the method `hasFeature` on `DOMImplementation`.
    `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 `true`.
  Returns:
    Returns `true` if the specified feature is supported on this node, `false` otherwise.
  Since:
    DOM Level 2

### appendChild

    public org.w3c.dom.Node appendChild(org.w3c.dom.Node newChild)
                                 throws org.w3c.dom.DOMException

  Adds the node `newChild` to the end of the list of children of this node. If the `newChild` is already in the tree, it is first removed.

  Specified by:
    `appendChild` in interface `org.w3c.dom.Node`
  Parameters:
    `newChild` - The node to add.If it is a `DocumentFragment` object, the entire contents of the document fragment are moved into the child list of this node
  Returns:
    The node added.
  Throws:
    `org.w3c.dom.DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to append is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the previous parent of the node being inserted is readonly.

### removeChild

    public org.w3c.dom.Node removeChild(org.w3c.dom.Node oldChild)
                                 throws org.w3c.dom.DOMException

  Removes the child node indicated by `oldChild` from the list of children, and returns it.

  Specified by:
    `removeChild` in interface `org.w3c.dom.Node`
  Parameters:
    `oldChild` - The node being removed.
  Returns:
    The node removed.
  Throws:
    `org.w3c.dom.DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NOT_FOUND_ERR: Raised if `oldChild` is not a child of this node.

### insertBefore

    public org.w3c.dom.Node insertBefore(org.w3c.dom.Node newChild,
                                         org.w3c.dom.Node refChild)
                                  throws org.w3c.dom.DOMException

  Inserts the node `newChild` before the existing child node `refChild`. If `refChild` is `null`, insert `newChild` at the end of the list of children.
  If `newChild` is a `DocumentFragment` object, all of its children are inserted, in the same order, before `refChild`. If the `newChild` is already in the tree, it is first removed.

  Specified by:
    `insertBefore` in interface `org.w3c.dom.Node`
  Parameters:
    `newChild` - The node to insert.
    `refChild` - The reference node, i.e., the node before which the new node must be inserted.
  Returns:
    The node being inserted.
  Throws:
    `org.w3c.dom.DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to insert is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the parent of the node being inserted is readonly.
    NOT_FOUND_ERR: Raised if `refChild` is not a child of this node.

### replaceChild

    public org.w3c.dom.Node replaceChild(org.w3c.dom.Node newChild,
                                         org.w3c.dom.Node oldChild)
                                  throws org.w3c.dom.DOMException

  Replaces the child node `oldChild` with `newChild` in the list of children, and returns the `oldChild` node.
  If `newChild` is a `DocumentFragment` object, `oldChild` is replaced by all of the `DocumentFragment` children, which are inserted in the same order. If the `newChild` is already in the tree, it is first removed.

  Specified by:
    `replaceChild` in interface `org.w3c.dom.Node`
  Parameters:
    `newChild` - The new node to put in the child list.
    `oldChild` - The node being replaced in the list.
  Returns:
    The node replaced.
  Throws:
    `org.w3c.dom.DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to put in is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of the new node is readonly.
    NOT_FOUND_ERR: Raised if `oldChild` is not a child of this node.

### getValue

    public java.lang.String getValue()

  Returns the the value of the immediate child of this `Node` object if a child exists and its value is text.

  Specified by:
    `getValue` in interface `Node`
  Returns:
    a `String` with the text of the immediate child of this `Node` object if (1) there is a child and (2) the child is a `Text` object; `null` otherwise

### setParentElement

    public void setParentElement(SOAPElement parent)
                          throws SOAPException

  Sets the parent of this `Node` object to the given `SOAPElement` object.

  Specified by:
    `setParentElement` in interface `Node`
  Parameters:
    `parent` - the `SOAPElement` object to be set as the parent of this `Node` object
  Throws:
    `SOAPException` - if there is a problem in setting the parent to the given element
  See Also:
    `getParentElement()`

### getParentElement

    public SOAPElement getParentElement()

  Returns the parent element of this `Node` object. This method can throw an `UnsupportedOperationException` if the tree is not kept in memory.

  Specified by:
    `getParentElement` in interface `Node`
  Returns:
    the `SOAPElement` object that is the parent of this `Node` object or `null` if this `Node` object is root
  Throws:
    `java.lang.UnsupportedOperationException` - if the whole tree is not kept in memory
  See Also:
    `setParentElement(javax.xml.soap.SOAPElement)`

### detachNode

    public void detachNode()

  Removes this `Node` object from the tree. Once removed, this node can be garbage collected if there are no application references to it.

  Specified by:
    `detachNode` in interface `Node`

### recycleNode

    public void recycleNode()

  Notifies the implementation that this `Node` object is no longer being used by the application and that the implementation is free to reuse this object for nodes that may be created later.

  Calling the method `recycleNode` implies that the method `detachNode` has been called previously.

  Specified by:
    `recycleNode` in interface `Node`

### setValue

    public void setValue(java.lang.String value)

  If this is a Text node then this method will set its value, otherwise it sets the value of the immediate (Text) child of this node. The value of the immediate child of this node can be set only if, there is one child node and that node is a Text node, or if there are no children in which case a child Text node will be created.

  Specified by:
    `setValue` in interface `Node`
  Parameters:
    `value` - the text to set
  Throws:
    `java.lang.IllegalStateException` - if the node is not a Text node and either has more than one child node or has a child node that is not a Text node

### makeAttributesEditable

    protected org.xml.sax.helpers.AttributesImpl makeAttributesEditable()

  make the attributes editable

  Returns:
    AttributesImpl

### convertAttrSAXtoDOM

    protected org.w3c.dom.NamedNodeMap convertAttrSAXtoDOM(org.xml.sax.Attributes saxAttr)

  The internal representation of Attributes cannot help being changed It is because Attribute is not immutible Type, so if we keep out value and just return it in another form, the application may chnae it, which we cannot detect without some kind back track method (call back notifying the chnage.) I am not sure which approach is better.

### initializeChildren

    protected void initializeChildren()

  Initialize the children array

### getParent

    protected NodeImpl getParent()

  get the parent node

  Returns:
    parent node

### setParent

    protected void setParent(NodeImpl parent)
                      throws SOAPException

  Set the parent node and invoke appendChild(this) to add this node to the parent's list of children.

  Parameters:
    `parent` -
  Throws:
    `SOAPException`

### output

    public void output(SerializationContext context)
                throws java.lang.Exception

  print the contents of this node

  Parameters:
    `context` -
  Throws:
    `java.lang.Exception`

### isDirty

    public boolean isDirty()

  get the dirty bit

  Returns:

### setDirty

    public void setDirty(boolean dirty)

  set the dirty bit. will also set our parent as dirty, if there is one. Note that clearing the dirty bit does not propagate upwards.

  Parameters:
    `dirty` - new value of the dirty bit

### setDirty

    public void setDirty()

### reset

    public void reset()

Copyright © 2005 Apache Web Services Project. All Rights Reserved.