# dom.h

This HTML document was auto-generated from dom.h

## Interface: Node

>     /*****************************************************************
>     Interface: Node
>     Desc:
>     From the DOM spec:
>     The Node interface is the primary datatype for the entire
>     Document Object Model. It represents a single node in the document tree.
>     While all objects implementing the Node interface expose
>     methods for dealing with children, not all objects implementing the
>     Node interface may have children. For example,
>     Text nodes may not have children, and adding children to such
>     nodes results in a DOMException being raised.
>     The attributes nodeName, nodeValue  and
>     attributes are  included as a mechanism to get at node
>     information without  casting down to the specific derived interface. In
>     cases where  there is no obvious mapping of these attributes for a specific
>     nodeType (e.g., nodeValue for an Element  or
>     attributes  for a Comment), this returns null.
>     Note that the  specialized interfaces may contain additional and more
>     convenient mechanisms to get and set the relevant information.
>     Notes:
>     This C/C++ binding adds the following methods to the DOM
>     level 1 specified methods:
>     void enableExceptions(int enable);
>     DOMException * getLastError();
>     void destroy();
>     *****************************************************************/

> ### Method: Node::getNodeName

>     //=========================================================================
>     // Method:	getNodeName
>     // Desc:	Return the name of this node.
>     //
>     // Notes:	Not all node types have a name
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Node::getNodeName(
>     );

> ### Method: Node::getNodeValue

>     //=========================================================================
>     // Method:	getNodeValue
>     // Desc:	Return the value of this node
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Node::getNodeValue(
>     );

> ### Method: Node::setNodeValue

>     //=========================================================================
>     // Method:	setNodeValue
>     // Desc:	Set the value of this node.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     // Notes:	Will return an error if the node is readonly
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Node::setNodeValue(
>     	const unicode * value
>     );

> ### Method: Node::getNodeType

>     //=========================================================================
>     // Method:	getNodeType
>     // Desc:	Return the type of this node, see enum NodeType.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     short
>     Node::getNodeType(
>     );

> ### Method: Node::getParentNode

>     //=========================================================================
>     // Method:	getParentNode
>     // Desc:	Return the parent of this node. All nodes, except Document,
>     //			DocumentFragment, and Attr may have a parent. However, if a
>     //			node has been created but not yet added to the tree this is
>     //			null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::getParentNode(
>     );

> ### Method: Node::getChildNodes

>     //=========================================================================
>     // Method:	getChildNodes
>     // Desc:	Return a NodeList with the children of this node. If the node
>     //			has no children this return an empty NodeList.
>     //
>     // Notes:	The returned NodeList must be deleted when it is no longer needed.
>     //			This must be done by calling the NodeList::destroy() method.
>     //
>     //			If this Node is deleted before the NodeList is destroyed, the
>     //			NodeList becomes invalid and results are unpredictable.
>     //=========================================================================

>     C++ Signature

>     NodeList *
>     Node::getChildNodes(
>     );

> ### Method: Node::getFirstChild

>     //=========================================================================
>     // Method:	getFirstChild
>     // Desc:	Return the first child of this node. If there is no such node
>     //			the return is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::getFirstChild(
>     );

> ### Method: Node::getLastChild

>     //=========================================================================
>     // Method:	getLastChild
>     // Desc:	Return the last child of this node. If there is no such node
>     //			the return is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::getLastChild(
>     );

> ### Method: Node::getPreviousSibling

>     //=========================================================================
>     // Method:	getPreviousSibling
>     // Desc:	Return the node immediately preceding this node. If there is no
>     //			such node the return is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::getPreviousSibling(
>     );

> ### Method: Node::getNextSibling

>     //=========================================================================
>     // Method:	getNextSibling
>     // Desc:	Return the node immediately following this node. If there is no
>     //			such node the return is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::getNextSibling(
>     );

> ### Method: Node::getAttributes

>     //=========================================================================
>     // Method:	getAttributes
>     // Desc:	Return a NamedNodeMap with a list of the attributes of this
>     //			node (if it is an Element), or null otherwise.
>     //
>     // Notes:	Note that the returned NamedNodeMap belongs to this node. No
>     //			attempt must be made to delete it.
>     //=========================================================================

>     C++ Signature

>     NamedNodeMap *
>     Node::getAttributes(
>     );

> ### Method: Node::getOwnerDocument

>     //=========================================================================
>     // Method:	getOwnerDocument
>     // Desc:	Return the Document object associated with this node. This is
>     //			also the Document object used to create new nodes. When this
>     //			node is a Document this returns null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Document *
>     Node::getOwnerDocument(
>     );

> ### Method: Node::insertBefore

>     //=========================================================================
>     // Method:	insertBefore
>     // Desc:	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.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				WRONG_DOCUMENT_ERR if this Node is of a type that does not
>     //				allow children of the newChild type, or if newChild is one
>     //				of this Node's ancestors
>     //				HIERARCHY_REQUEST_ERR if newChild is of a type that is not
>     //				allowed as a child of this Node.
>     //				NOT_FOUND_ERR if refChild is not a child of this Node
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::insertBefore(
>     	Node * newChild,
>     	Node * refChild
>     );

> ### Method: Node::replaceChild

>     //=========================================================================
>     // Method:	replaceChild
>     // Desc:	Replaces the child node oldChild with the newChild in the list
>     //			of children and returns the oldChild node. If the newChild is
>     //			already in the tree, it is first removed.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				WRONG_DOCUMENT_ERR if this Node is of a type that does not
>     //				allow children of the newChild type, or if newChild is one
>     //				of this Node's ancestors
>     //				HIERARCHY_REQUEST_ERR if newChild is of a type that is not
>     //				allowed as a child of this Node.
>     //				NOT_FOUND_ERR if refChild is not a child of this Node
>     //
>     // Notes:	C/C++ specific: The destroy() method must be called on the
>     //			returned node.
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::replaceChild(
>     	Node * newChild,
>     	Node * oldChild
>     );

> ### Method: Node::removeChild

>     //=========================================================================
>     // Method:	removeChild
>     // Desc::	Removes the child indicated by oldChild from the list of
>     //			children and returns it.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				NOT_FOUND_ERR if refChild is not a child of this Node
>     //
>     // Notes:	C/C++ specific: The destroy() method must be called on the
>     //			returned node.
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::removeChild(
>     	Node * oldChild
>     );

> ### Method: Node::appendChild

>     //=========================================================================
>     // Method:	appendChild
>     // Desc:	Adds the node newChild to the end of the list of children of
>     //			this node. If newChild is already in the tree, it is first
>     //			removed.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				WRONG_DOCUMENT_ERR if this Node is of a type that does not
>     //				allow children of the newChild type, or if newChild is one
>     //				of this Node's ancestors
>     //				HIERARCHY_REQUEST_ERR if newChild is of a type that is not
>     //				allowed as a child of this Node.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::appendChild(
>     	Node * newChild
>     );

> ### Method: Node::hasChildNodes

>     //=========================================================================
>     // Method:	hasChildNodes
>     // Desc:	This is a convenience method to allow easy determination of
>     //			whether a node has any children. Returns non-zero if this node
>     //			has children.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     Node::hasChildNodes(
>     );

> ### Method: Node::cloneNode

>     //=========================================================================
>     // Method:	cloneNode
>     // Desc:	Returns a duplicate of this node, i.e., serves as a generic
>     //			copy constructor for nodes. The duplicate node has no parent
>     //			(getParentNode() returns null).
>     //
>     //			Cloning an Element copies all attributes and their values,
>     //			including those generated by an 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 any other type of node
>     //			simply returns a copy of this node.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     Node::cloneNode(
>     	int deep                                        //if non-zero recursively clone the subtree under this node
>     );

> ### Method: Node::getLastError

>     //=========================================================================
>     // Method:	getLastError
>     // Desc:	Return the DOMException generated by the last operation on this
>     //			node. If no exception was generated, return null.
>     //
>     // Notes:	C Extension to DOM level 1
>     //			The DOMException returned by this method belongs to the Node.
>     //			No attempt should be made to delete it.
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Node::getLastError(
>     );

> ### Method: Node::destroy

>     //=========================================================================
>     // Method:	destroy
>     // Desc:	Delete this node. If this node is currently in the tree, then
>     //			this is equivalent to calling removeChild() on this node's
>     //			parent then destroy() on this node. If this node is a Document
>     //			object then the entire tree is destroyed.
>     //
>     // Notes:	C/C++ extension to DOM level 1
>     //=========================================================================

>     C++ Signature

>     void
>     Node::destroy(
>     );

## Interface: Document

> Inherits from Node

>     /*****************************************************************
>     Interface: Document
>     Desc:
>     From the DOM spec:
>     The Document interface represents the entire HTML or XML
>     document. Conceptually, it is the root of the document tree, and provides
>     the  primary access to the document's data.
>     Since elements, text nodes, comments, processing instructions, etc.
>     cannot exist outside the context of a Document, the
>     Document interface also contains the factory methods needed
>     to create these objects.  The Node objects created have a
>     ownerDocument attribute which associates them with the
>     Document within whose  context they were created.
>     Notes:
>     *****************************************************************/

> ### Method: Document::getDoctype

>     //=========================================================================
>     // Method:	getDoctype
>     // Desc:	Returns the DocumentType node associated with this document.
>     //			For documents without a Document Type Declaration this returns
>     //			null.
>     //
>     //			The DOM level does not support editing the Document Type
>     //			Declaration, therefore the DocumentType cannot be altered in
>     //			any way.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DocumentType *
>     Document::getDoctype(
>     );

> ### Method: Document::getImplementation

>     //=========================================================================
>     // Method:	getImplementation
>     // Desc:	Return the DOMImplementation object that handles this document.
>     //			A DOM application may use objects from multiple implementations.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMImplementation *
>     Document::getImplementation(
>     );

> ### Method: Document::getDocumentElement

>     //=========================================================================
>     // Method:	getDocumentElement
>     // Desc:	This is a convenience method that allows direct acess to the
>     //			child node that is the root element of the document. If there
>     //			is more than one element as a child of the Document object then
>     //			the first element child is returned. If there is no document
>     //			element, null is returned.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Element *
>     Document::getDocumentElement(
>     );

> ### Method: Document::createElement

>     //=========================================================================
>     // Method:	createElement
>     // Desc:	Creates an element of the type specified. Note that the
>     //			instance returned implements the Element interface, so
>     //			attributes can be specified directly on the returned object.
>     //
>     //			DOMException registered or thrown:
>     //				INVALID_CHARACTER_ERROR: If tagName is invalid
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Element *
>     Document::createElement(
>     	const unicode * tagName
>     );

> ### Method: Document::createDocumentFragment

>     //=========================================================================
>     // Method:	createDocumentFragment
>     // Desc:	Creates an empty DocumentFragment object.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DocumentFragment *
>     Document::createDocumentFragment(
>     );

> ### Method: Document::createTextNode

>     //=========================================================================
>     // Method:	createTextNode
>     // Desc:	Creates a Text node given the specified string.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Text *
>     Document::createTextNode(
>     	const unicode * data,
>     	int offset,
>     	int length
>     );

> ### Method: Document::createComment

>     //=========================================================================
>     // Method:	createComment
>     // Desc:	Creates a Comment node given the specified string.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Comment *
>     Document::createComment(
>     	const unicode * data
>     );

> ### Method: Document::createCDATASection

>     //=========================================================================
>     // Method:	createCDATASection
>     // Desc:	Creates a CDATASection node whose value is the specified string.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     CDATASection *
>     Document::createCDATASection(
>     	const unicode * data,
>     	int offset,
>     	int length
>     );

> ### Method: Document::createProcessingInstruction

>     //=========================================================================
>     // Method:	createProcessingInstruction
>     // Desc:	Creates a ProcessingInstruction node given the specified
>     //			target and data strings.
>     //
>     //			DOMException registered or thrown:
>     //				INVALID_CHARACTER_ERROR: If target or data is invalid
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     ProcessingInstruction *
>     Document::createProcessingInstruction(
>     	const unicode * target,
>     	const unicode * data
>     );

> ### Method: Document::createAttribute

>     //=========================================================================
>     // Method:	createAttribute
>     // Desc:	Creates an Attr of the given name. Note that the Attr instance
>     //			can then be set on an Element using the setAttribute() method.
>     //
>     //			DOMException registered or thrown:
>     //				INVALID_CHARACTER_ERROR: If name is invalid
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Attr *
>     Document::createAttribute(
>     	const unicode * name
>     );

> ### Method: Document::createEntityReference

>     //=========================================================================
>     // Method:	createEntityReference
>     // Desc:	Creates an EntityReference object.
>     //
>     //			DOMException registered or thrown:
>     //				INVALID_CHARACTER_ERROR: If name is invalid
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     EntityReference *
>     Document::createEntityReference(
>     	const unicode * name
>     );

> ### Method: Document::getElementsByTagName

>     //=========================================================================
>     // Method:	getElementsByTagName
>     // Desc:	Returns a NodeList of all the Elements with a given tag name
>     //			in the order in which they would be encountered in a preorder
>     //			traversal of the Document tree.
>     //
>     // Notes:	The returned NodeList must be deleted when it is no longer needed.
>     //			This must be done by calling the NodeList::destroy() method.
>     //
>     //			If this Node is deleted before the NodeList is destroyed, the
>     //			NodeList becomes invalid and results are unpredictable.
>     //=========================================================================

>     C++ Signature

>     NodeList *
>     Document::getElementsByTagName(
>     	const unicode * tagName
>     );

> ### Method: Document::enableExceptions

>     //=========================================================================
>     // Method:	enableExceptions
>     // Desc:	Enable the throwing of C++ exceptions for all nodes created
>     //			by this Document and for all nodes in this Document object's
>     //			tree.
>     //
>     // Notes:	C++ Extension to DOM level 1
>     //			A C implementation of the DOM will not support this and will
>     //			always return 0, indicating exceptions are not supported.
>     //=========================================================================

>     C++ Signature

>     int
>     Node::enableExceptions(
>     	int enable
>     );

## Interface: DocumentFragment

> Inherits from Node

>     /*****************************************************************
>     Interface: DocumentFragment
>     Desc:
>     From the DOM spec:
>     DocumentFragment is a "lightweight" or "minimal"
>     Document object. It is very common to want to be able to
>     extract a portion of a document's tree or to create a new fragment of a
>     document. Imagine implementing a user command like cut or rearranging a
>     document by moving fragments around. It is desirable to have an object
>     which can hold such fragments and it is quite natural to use a Node for
>     this purpose. While it is true that a Document object could
>     fulfil this role,  a Document object can potentially be a
>     heavyweight  object, depending on the underlying implementation. What is
>     really needed for this is a very lightweight object.
>     DocumentFragment is such an object.
>     Furthermore, various operations -- such as inserting nodes as children
>     of another Node -- may take DocumentFragment
>     objects as arguments;  this results in all the child nodes of the
>     DocumentFragment  being moved to the child list of this node.
>     The children of a DocumentFragment node are zero or more
>     nodes representing the tops of any sub-trees defining the structure of the
>     document. DocumentFragment nodes do not need to be
>     well-formed XML documents (although they do need to follow the rules
>     imposed upon well-formed XML parsed entities, which can have multiple top
>     nodes).  For example, a DocumentFragment might have only one
>     child and that child node could be a Text node. Such a
>     structure model  represents neither an HTML document nor a well-formed XML
>     document.
>     When a DocumentFragment is inserted into a
>     Document (or indeed any other Node that may take
>     children) the children of the DocumentFragment and not the
>     DocumentFragment  itself are inserted into the
>     Node. This makes the DocumentFragment very
>     useful when the user wishes to create nodes that are siblings; the
>     DocumentFragment acts as the parent of these nodes so that the
>     user can use the standard methods from the Node  interface,
>     such as insertBefore() and  appendChild().
>     Notes:
>     *****************************************************************/

## Interface: Element

> Inherits from Node

>     /*****************************************************************
>     Interface: Element
>     Desc:
>     From the DOM spec:
>     By far the vast majority of objects (apart from text) that authors
>     encounter when traversing a document are Element nodes.
>     Assume the following XML document:<elementExample id="demo">
>     <subelement1/>
>     <subelement2><subsubelement/></subelement2>
>     </elementExample>
>     When represented using DOM, the top node is an Element node
>     for "elementExample", which contains two child Element nodes,
>     one for "subelement1" and one for "subelement2". "subelement1" contains no
>     child nodes.
>     Elements may have attributes associated with them; since the
>     Element interface inherits from Node, the generic
>     Node interface method getAttributes may be used
>     to retrieve the set of all attributes for an element.  There are methods on
>     the Element interface to retrieve either an Attr
>     object by name or an attribute value by name. In XML, where an attribute
>     value may contain entity references, an Attr object should be
>     retrieved to examine the possibly fairly complex sub-tree representing the
>     attribute value. On the other hand, in HTML, where all attributes have
>     simple string values, methods to directly access an attribute value can
>     safely be used as a convenience.
>     Notes:
>     *****************************************************************/

> ### Method: Element::getTagName

>     //=========================================================================
>     // Method:	getTagName
>     // Desc:	Return the name of the element.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Element::getTagName(
>     );

> ### Method: Element::getAttribute

>     //=========================================================================
>     // Method:	getAttribute
>     // Desc:	Return an attribute value by name. If the element does not
>     //			have an attribute with the passed name null is returned.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Element::getAttribute(
>     	const unicode * name                            //the name of the attribute
>     );

> ### Method: Element::setAttribute

>     //=========================================================================
>     // Method:	setAttribute
>     // Desc:	Adds a new attribute. If an attribute with that name is already
>     //			present in the element, its value is changed to be that of the
>     //			value parameter. This value is a simple string. it is not parsed
>     //			as it is being set. So any markup (such as syntax to be
>     //			recognized an an entity reference) is treated as literal text
>     //			and needs to be appropriately escaped by the implementation
>     //			when it is written out. In order to assign an attribute value
>     //			that contains entity references, the user must create an Attr
>     //			node plus any Text and EntityReference nodes, build the
>     //			appropriate sub tree, and use setAttributeNode() to assign it
>     //			as the value of an attribute.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				INVALID_CHARACTER_ERR if name is invalid
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Element::setAttribute(
>     	const unicode * name,                           //the name of the attribute
>     	const unicode * value                           //the value of the attribute
>     );

> ### Method: Element::removeAttribute

>     //=========================================================================
>     // Method:	removeAttribute
>     // Desc:	Removes an attribute by name. If the removed attribute has a
>     //			default value it is immediately replaced.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Element::removeAttribute(
>     	const unicode * name                            //the name of the attribute
>     );

> ### Method: Element::getAttributeNode

>     //=========================================================================
>     // Method:	getAttributeNode
>     // Desc:	Retrieves an Attr node by name. This returns null is there is
>     //			no attribute by the passed name.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Attr *
>     Element::getAttributeNode(
>     	const unicode * name                            //the name of the attribute
>     );

> ### Method: Element::setAttributeNode

>     //=========================================================================
>     // Method:	setAttributeNode
>     // Desc:	Adds a new attribute. If an attribute with that name is already
>     //			present in the element, it is replaced by the new one.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				WRONG_DOCUMENT_ERR if this Node is of a type that does not
>     //				allow children of the newChild type, or if newChild is one
>     //				of this Node's ancestors
>     //				INUSE_ATTRIBUTE_ERR if newAttr is an Attr that already belongs
>     //				to another Element.
>     //
>     // Notes:	If the new Attr replaces an existing Attr node the previously
>     //			existing Attr node is returned (and must be destroyed), otherwise
>     //			null is returned.
>     //=========================================================================

>     C++ Signature

>     Attr *
>     Element::setAttributeNode(
>     	Attr * newAttr                                  //the new Attr node
>     );

> ### Method: Element::removeAttributeNode

>     //=========================================================================
>     // Method:	removeAttributeNode
>     // Desc:	Removes the specified attribute.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				NOT_FOUND_ERR if oldAttr is not an attribute of this Node
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Attr *
>     Element::removeAttributeNode(
>     	Attr * oldAttr                                  //the Attr node to remove
>     );

> ### Method: Element::getElementsByTagName

>     //=========================================================================
>     // Method:	getElementsByTagName
>     // Desc:	Returns a NodeList of all descendant elements with a given
>     //			tag name, in the order in which they would be encountered in a
>     //			preorder traversal of the Element tree.
>     //
>     // Notes:	The special tag name value "*" matches all tags.
>     //			The returned NodeList must be deleted when it is no longer needed.
>     //			This must be done by calling the NodeList::destroy() method.
>     //
>     //			If this Node is deleted before the NodeList is destroyed, the
>     //			NodeList becomes invalid and results are unpredictable.
>     //=========================================================================

>     C++ Signature

>     NodeList *
>     Document::getElementsByTagName(
>     	const unicode * tagName                         //the name of the tag to match on.
>     );

> ### Method: Element::normalize

>     //=========================================================================
>     // Method:	normalize
>     // Desc:	Puts all Text nodes in the full depth of the sub-tree underneath
>     //			this Element into a "normal" form where only markup (e.g., tags,
>     //			comments, processing instructions, CDATA sections, and entity
>     //			references separates Text nodes, i.e., there are no adjacent
>     //			Text nodes. This can be used to ensure that the DOM view of a
>     //			document is the same 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.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Element::normalize(
>     );

## Interface: Attr

> Inherits from Node

>     /*****************************************************************
>     Interface: Attr
>     Desc:
>     From the DOM spec:
>     The Attr interface represents an attribute in an
>     Element object.Typically the allowable values for the
>     attribute are defined in a documenttype definition.
>     Attr objects inherit the Node  interface, but
>     since they are not actually child nodes of the element  they describe, the
>     DOM does not consider them part of the document  tree.  Thus, the
>     Node attributes parentNode,
>     previousSibling, and nextSibling have a  null
>     value for Attr objects. The DOM takes the  view that
>     attributes are properties of elements rather than having a  separate
>     identity from the elements they are associated with;  this should make it
>     more efficient to implement such features as default attributes associated
>     with all elements of a  given type.  Furthermore, Attr nodes
>     may not be immediate children of a DocumentFragment. However,
>     they can be associated with Element nodes contained within a
>     DocumentFragment. In short, users and implementors of the DOM
>     need to be aware that  Attr nodes have some things in  common
>     with other objects inheriting the Node interface,  but they
>     also are quite distinct.
>      The attribute's effective value is determined as follows: if this
>     attribute has been explicitly assigned any value, that value is the
>     attribute's effective value; otherwise, if there is a declaration for
>     this attribute, and that declaration includes a default value, then  that
>     default value is the attribute's effective value; otherwise, the
>     attribute does not exist on this element in the structure model until  it
>     has been explicitly added.  Note that the nodeValue
>     attribute on the Attr instance can also be used to retrieve
>     the string version of the attribute's value(s).
>     In XML, where the value of an attribute can contain entity references,
>     the child nodes of the Attr node provide a representation in
>     which entity references are not expanded. These child nodes may be either
>     Text or EntityReference nodes. Because the
>     attribute type may be unknown, there are no tokenized attribute values.
>     Notes:
>     *****************************************************************/

> ### Method: Attr::getName

>     //=========================================================================
>     // Method:	getName
>     // Desc:	Returns the name of this attribute.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Attr::getName(
>     );

> ### Method: Attr::getSpecified

>     //=========================================================================
>     // Method:	getSpecified
>     // Desc:	If this attribute was explicitly given a value in the original
>     //			document this is TRUE; otherwise it is FALSE. Note that the
>     //			implementation is in charge of this attribute, not the user. If
>     //			the user changes the value of the attribute (even if it ends up
>     //			having the same value as the default value) then the specified
>     //			flag is automatically flipped to TRUE. To re-specify the
>     //			attribute as the default value from the DTD, the user must delete
>     //			the attribute. The implementation will then make a new attribute
>     //			available with the specified flag set to false and the default
>     //			value (if one exists).
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     Attr::getSpecified(
>     );

> ### Method: Attr::getValue

>     //=========================================================================
>     // Method:	getValue
>     // Desc:	On retrieval, the value of the attribute is returned as a
>     //			string. Character and general entity references are replaced
>     //			with their values.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Attr::getValue(
>     );

> ### Method: Attr::setValue

>     //=========================================================================
>     // Method:	setValue
>     // Desc:	On setting, this creates a Text node with the unparsed contents
>     //			of the string.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     Attr::setValue(
>     	const unicode * value                           //the new attribute value
>     );

## Interface: CharacterData

> Inherits from Node

>     /*****************************************************************
>     Interface: CharacterData
>     Desc:
>     From the DOM spec:
>     The CharacterData interface extends Node with a set  of
>     attributes and methods for accessing character data in the DOM.  For
>     clarity this set is defined here rather than on each object that uses
>     these attributes and methods. No DOM objects correspond directly to
>     CharacterData, though Text and others do inherit
>     the interface from it. All offsets in this interface start
>     from 0.
>     Notes:
>     *****************************************************************/

> ### Method: CharacterData::getData

>     //=========================================================================
>     // Method:	getData
>     // Desc:	Return the character data of the node that implements this
>     //			interface. The DOM implementation may not put arbitrary limits
>     //			on the amount of data that may be stored in a CharacterData
>     //			node. However, implementation limits may mean that the
>     //			entirety of a node's data may not fit into a single string. In
>     //			such cases the user may call substringData to retrieve the data
>     //			in appropriately sized pieces.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     CharacterData::getData(
>     );

> ### Method: CharacterData::setData

>     //=========================================================================
>     // Method:	setData
>     // Desc:	Set the character data of the node that implements this interface.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     CharacterData::setData(
>     	const unicode * data                            //The character data for this node
>     );

> ### Method: CharacterData::getLength

>     //=========================================================================
>     // Method:	getLength
>     // Desc:	The number of characters that are available through getData()
>     //			and the substringData() method below. This may have the value
>     //			zero, i.e., CharacterData nodes may be empty
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     CharacterData::getLength(
>     );

> ### Method: CharacterData::substringData

>     //=========================================================================
>     // Method:	substringData
>     // Desc:	Extracts a range of data from the node.
>     //
>     //			DOMException registered or thrown:
>     //				INDEX_SIZE_ERR if the specified offset is negative or greater
>     //				than the number of characters in data, or if the
>     //				specified count is negative.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     CharacterData::substringData(
>     	int offset,                                     //Start offset of substring to extract
>     	int count                                       //The number of characters to extract
>     );

> ### Method: CharacterData::appendData

>     //=========================================================================
>     // Method:	appendData
>     // Desc:	Append the string to the end of the character data of the node.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     CharacterData::appendData(
>     	const unicode * arg                             //The string to append
>     );

> ### Method: CharacterData::insertData

>     //=========================================================================
>     // Method:	insertData
>     // Desc:	Insert a string at the specified character offset.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				INDEX_SIZE_ERR if the specified offset is negative or greater
>     //				than the number of characters in data
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     CharacterData::insertData(
>     	int offset,                                     //The character offset at which to insert
>     	const unicode * arg                             //The string to insert
>     );

> ### Method: CharacterData::deleteData

>     //=========================================================================
>     // Method:	deleteData
>     // Desc:	Remove a range of characters from the node.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				INDEX_SIZE_ERR if the specified offset is negative or greater
>     //				than the number of characters in data, or if the
>     //				specified count is negative.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     CharacterData::deleteData(
>     	int offset,                                     //The offset from which to remove characters
>     	int count                                       //The number of characters to delete.
>     );

> ### Method: CharacterData::replaceData

>     //=========================================================================
>     // Method:	replaceData
>     // Desc:	Replace the characters starting at the specified character
>     //			offset within the specified string.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				INDEX_SIZE_ERR if the specified offset is negative or greater
>     //				than the number of characters in data, or if the
>     //				specified count is negative.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     CharacterData::replaceData(
>     	int offset,                                     //The offset from which to start replacing
>     	int count,                                      //The number of characters to replace
>     	const unicode * arg                             //The string with which the range must be replaced
>     );

## Interface: Text

> Inherits from CharacterData

>     /*****************************************************************
>     Interface: Text
>     Desc:
>     From the DOM spec:
>     The Text interface represents the textual content (termed
>     character  data in XML) of an Element or Attr.
>     If there is no markup inside an element's content, the text is contained
>     in a single object implementing the Text interface that is
>     the only child of the element. If there is markup, it is parsed into a
>     list of elements and Text nodes that form the list of
>     children of the element.
>     When a document is first made available via the DOM, there is  only one
>     Text node for each block of text. Users may create  adjacent
>     Text nodes that represent the  contents of a given element
>     without any intervening markup, but should be aware that there is no way
>     to represent the separations between these nodes in XML or HTML, so they
>     will not (in general) persist between DOM editing sessions. The
>     normalize() method on Element merges any such
>     adjacent Text objects into a single node for each block of
>     text; this is  recommended before employing operations that depend on a
>     particular document structure, such as navigation with
>     XPointers.
>     Notes:
>     *****************************************************************/

> ### Method: Text::splitText

>     //=========================================================================
>     // Method:	splitText
>     // Desc:	Breaks this Text node into two Text nodes at the specified
>     //			offset, keeping both in the tree as siblings. This node then
>     //			only contains all the content up to the offset point. And a new
>     //			Text node, which is inserted as the next sibling of this node,
>     //			contains all the content at and after the offset point.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //				INDEX_SIZE_ERR if the specified offset is negative or greater
>     //				than the number of characters in data
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Text *
>     Text::splitText(
>     	int offset                                      //The offset at which to split, starting from 0
>     );

## Interface: CDATASection

> Inherits from Text

>     /*****************************************************************
>     Interface: CDATASection
>     Desc:
>     From the DOM spec:
>     CDATA sections are used to escape blocks of text containing  characters
>     that would otherwise be regarded as markup. The only  delimiter that is
>     recognized in a CDATA section is the "]]>" string  that ends the CDATA
>     section. CDATA sections can not be  nested. The primary purpose is for
>     including material such as XML fragments, without needing to escape all
>     the delimiters.
>     The DOMString attribute of the Text node holds
>     the text that is contained by the CDATA section. Note that this may
>     contain characters that need to be escaped outside of CDATA sections and
>     that, depending on the character encoding ("charset") chosen for
>     serialization, it may be impossible to write out some characters as part
>     of a CDATA section.
>      The CDATASection interface inherits the
>     CharacterData interface through the Text
>     interface. Adjacent CDATASections nodes are not merged by use
>     of the Element.normalize() method.
>     Notes:
>     *****************************************************************/

## Interface: Comment

> Inherits from CharacterData

>     /*****************************************************************
>     Interface: Comment
>     Desc:
>     From the DOM spec:
>     This represents the content of a comment, i.e., all the characters between
>     the starting '<!--' and ending '-->'. Note
>     that this is the definition of a comment in XML, and, in practice, HTML,
>     although some HTML tools may implement the full SGML comment structure.
>     Notes:
>     *****************************************************************/

## Interface: ProcessingInstruction

> Inherits from Node

>     /*****************************************************************
>     Interface: ProcessingInstruction
>     Desc:
>     From the DOM spec:
>     The ProcessingInstruction interface represents a  "processing
>     instruction", used in XML as a way to keep processor-specific information
>     in the text of the document.
>     Notes:
>     *****************************************************************/

> ### Method: ProcessingInstruction::getTarget

>     //=========================================================================
>     // Method:	getTarget
>     // Desc:	Return the target of this ProcessingInstruction node. XML
>     //			defines this as being the first token following the markup
>     //			that begins the processing instruction.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     ProcessingInstruction::getTarget(
>     );

> ### Method: ProcessingInstruction::getData

>     //=========================================================================
>     // Method:	getData
>     // Desc:	Return the content of this ProcessingInstruction node. This is
>     //			from the first non white space character after the target to
>     //			the character immediately preceding the ?>.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     ProcessingInstruction::getData(
>     );

> ### Method: ProcessingInstruction::setData

>     //=========================================================================
>     // Method:	setData
>     // Desc:	Set the content of this ProcessingInstruction node. This is
>     //			from the first non white space character after the target to
>     //			the character immediately preceding the ?>.
>     //
>     //			DOMException returned or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if Node is read only
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     DOMException *
>     ProcessingInstruction::setData(
>     	const unicode * data
>     );

## Interface: DocumentType

> Inherits from Node

>     /*****************************************************************
>     Interface: DocumentType
>     Desc:
>     From the DOM spec:
>     Each Document has a doctype attribute whose value
>     is either null or a DocumentType object. The
>     DocumentType interface in the DOM Level 1 Core provides an
>     interface to the list of entities that are defined for the document, and
>     little else because the effect of namespaces and the various XML scheme
>     efforts on DTD representation are not clearly understood as of this
>     writing.
>     The DOM Level 1 doesn't support editing DocumentType nodes.
>     Notes:
>     *****************************************************************/

> ### Method: DocumentType::getName

>     //=========================================================================
>     // Method:	getName
>     // Desc:	The name of the DTD; i.e., the name immediately following the
>     //			DOCTYPE keyword.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     DocumentType::getName(
>     );

> ### Method: DocumentType::getEntities

>     //=========================================================================
>     // Method:	getEntities
>     // Desc:	Return a NamedNodeMap containing the general entities, both
>     //			external and internal, declared in the DTD. Duplicates are
>     //			discarded. Every Node in this map also implements the Entity
>     //			interface.
>     //
>     // Notes:	Note that the returned NamedNodeMap belongs to this node. No
>     //			attempt must be made to delete it.
>     //=========================================================================

>     C++ Signature

>     NamedNodeMap *
>     DocumentType::getEntities(
>     );

> ### Method: DocumentType::getNotations

>     //=========================================================================
>     // Method:	getNotations
>     // Desc:	Return a NamedNodeMap containing the notations declared in the
>     //			DTD. Duplicates are discarded. Every Node in this map also
>     //			implements the Notation interface.
>     //
>     // Notes:	Note that the returned NamedNodeMap belongs to this node. No
>     //			attempt must be made to delete it.
>     //=========================================================================

>     C++ Signature

>     NamedNodeMap *
>     DocumentType::getNotations(
>     );

## Interface: DOMImplementation

>     /*****************************************************************
>     Interface: DOMImplementation
>     Desc:
>     From the DOM spec:
>     The DOMImplementation interface provides a number of methods
>     for performing operations that are independent of any particular instance
>     of the document object model.
>     The DOM Level 1 does not specify a way of creating a document instance,
>     and hence document creation is an operation specific to an implementation.
>     Future Levels of the DOM specification are expected to provide methods for
>     creating documents directly.
>     Notes:
>     *****************************************************************/

> ### Method: DOMImplementation::hasFeature

>     //=========================================================================
>     // Method:	hasFeature
>     // Desc:	Test if the DOM implementation implements a specific feature.
>     //
>     // Notes:	In Level 1, the legal value for feature are "HTML" and "XML"
>     //			(case insensitive). In Level 1 this is the string "1.0". If the
>     //			version is not specified, supporting any version of the feature
>     //			will cause the method to return non-zero (TRUE).
>     //=========================================================================

>     C++ Signature

>     int
>     DOMImplementation::hasFeature(
>     	const unicode * feature,                        //The package name of the feature to test
>     	const unicode * version                         //The version number of the package name to test
>     );

## Interface: Entity

> Inherits from Node

>     /*****************************************************************
>     Interface: Entity
>     Desc:
>     From the DOM spec:
>     This interface represents an entity, either parsed or unparsed, in an XML
>     document. Note that this models the entity itself not the entity
>     declaration. Entity declaration modeling has been left for a
>     later Level of the DOM specification.
>     The nodeName attribute that is inherited from
>     Node contains the name of the entity.
>     An XML processor may choose to completely expand entities before  the
>     structure model is passed to the DOM; in this case there will be no
>     EntityReference nodes in the document tree.
>     XML does not mandate that a non-validating XML processor read and
>     process entity declarations  made in the external subset or declared in
>     external parameter entities. This means that parsed entities declared in
>     the external subset need not be expanded by some classes of applications,
>     and that the replacement value of the entity may not be available. When the
>     replacement value is available, the corresponding  Entity
>     node's child list represents the structure of that replacement text.
>     Otherwise, the child list is empty.
>     The resolution of the children of the Entity (the
>     replacement value) may be lazily evaluated; actions by the user (such as
>     calling the childNodes method on the Entity
>     Node) are assumed to trigger the evaluation.
>     The DOM Level 1 does not support editing Entity nodes; if a
>     user wants to make changes to the contents of an Entity,
>     every related EntityReference node has to be replaced in the
>     structure model by a clone of the Entity's contents, and then
>     the desired changes must be made to each of those clones instead. All the
>     descendants of an Entity node are readonly.
>     An Entity node does not have any parent.
>     Notes:
>     *****************************************************************/

> ### Method: Entity::getPublicId

>     //=========================================================================
>     // Method:	getPublicId
>     // Desc:	Return the public identifier associated with the entity, if
>     //			specified. If the public identifier was not specified, this is
>     //			null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Entity::getPublicId(
>     );

> ### Method: Entity::getSystemId

>     //=========================================================================
>     // Method:	getSystemId
>     // Desc:	Return the system identifier associated with the entity, if
>     //			specified. If the system identifier was not specified, this is
>     //			null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Entity::getSystemId(
>     );

> ### Method: Entity::getNotationName

>     //=========================================================================
>     // Method:	getNotationName
>     // Desc:	For unparsed entities, the name of the notation for the entity.
>     //			For parsed entities, this is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Entity::getNotationName(
>     );

## Interface: EntityReference

> Inherits from Node

>     /*****************************************************************
>     Interface: EntityReference
>     Desc:
>     From the DOM spec:
>     EntityReference objects may be inserted into the structure
>     model when an entity reference is in the source document, or when the user
>     wishes to insert an entity reference. Note that  character references and
>     references to predefined entities are considered to be expanded by the
>     HTML or XML processor so that characters are represented by their Unicode
>     equivalent rather than by an entity reference. Moreover, the XML
>     processor may completely expand references to entities while building the
>     structure model, instead of providing EntityReference
>     objects. If it does provide such objects, then for a given
>     EntityReference node, it may be that there is no
>     Entity node representing the referenced entity; but if such
>     an Entity exists, then the child list of the
>     EntityReference node is the same as that of the
>     Entity node. As with the Entity node, all
>     descendants of the EntityReference are readonly.
>     The resolution of the children of the EntityReference (the
>     replacement value of the referenced Entity) may be lazily
>     evaluated; actions by the user (such as calling the
>     childNodes method on the EntityReference node)
>     are assumed to trigger the evaluation.
>     Notes:
>     *****************************************************************/

## Interface: Notation

> Inherits from Node

>     /*****************************************************************
>     Interface: Notation
>     Desc:
>     From the DOM spec:
>     This interface represents a notation declared in the DTD. A notation either
>     declares, by name, the format of an unparsed entity (see section 4.7 of
>     the XML 1.0 specification), or is used for formal declaration of
>     Processing Instruction targets (see section 2.6 of the XML 1.0
>     specification). The nodeName attribute inherited from
>     Node is set to the declared name of the notation.
>     The DOM Level 1 does not support editing Notation nodes;
>     they are therefore readonly.
>     A Notation node does not have any parent.
>     Notes:
>     *****************************************************************/

> ### Method: Notation::getPublicId

>     //=========================================================================
>     // Method:	getPublicId
>     // Desc:	The public identifier of this notation. If the public identifier
>     //			was not specified, this is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Entity::getPublicId(
>     );

> ### Method: Notation::getSystemId

>     //=========================================================================
>     // Method:	getSystemId
>     // Desc:	The system identifier of this notation. If the system identifier
>     //			was not specified, this is null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     Entity::getSystemId(
>     );

## Interface: NamedNodeMap

>     /*****************************************************************
>     Interface: NamedNodeMap
>     Desc:
>     From the DOM spec:
>     Objects implementing the NamedNodeMap interface are used to
>     represent collections of nodes that can be accessed by name. Note that
>     NamedNodeMap does not inherit from NodeList;
>     NamedNodeMaps are not maintained in any particular order.
>     Objects contained in an object implementing NamedNodeMap may
>     also be accessed by an ordinal index, but this is simply to allow
>     convenient enumeration of the contents of a NamedNodeMap, and
>     does not imply that the DOM specifies an order to these Nodes.
>     Notes:
>     *****************************************************************/

> ### Method: NamedNodeMap::getNamedItem

>     //=========================================================================
>     // Method:	getNamedItem
>     // Desc:	Retrieves a node specified by name.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     NamedNodeMap::getNamedItem(
>     	const unicode * name                            //Name of a node to retrieve
>     );

> ### Method: NamedNodeMap::setNamedItem

>     //=========================================================================
>     // Method:	setNamedItem
>     // Desc:	Adds a node using its nodeName attribute.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if NamedNodeMap is read only
>     //				WRONG_DOCUMENT_ERR if arg was created with a different
>     //				Document than the NamedNodeMap belongs to.
>     //				INUSE_ATTRIBUTE_ERR if arg is an Attr that already belongs
>     //				to another Element.
>     //
>     // Notes:	As the node name attribute is used to derive the name which
>     //			the node must be stored under, multiple nodes of certain types
>     //			(those that have a "special" string value) cannot be stored as
>     //			the names would clash.
>     //=========================================================================

>     C++ Signature

>     Node *
>     NamedNodeMap::setNamedItem(
>     	Node * arg                                      //A node to store in the map
>     );

> ### Method: NamedNodeMap::removedNamedItem

>     //=========================================================================
>     // Method:	removedNamedItem
>     // Desc:	Removes a node specified by name. If the removed node is an
>     //			Attr with a default value it is immediately replaced.
>     //
>     //			DOMException registered or thrown:
>     //				NO_MODIFICATION_ALLOWED_ERR if NamedNodeMap is read only
>     //				NOT_FOUND_ERR if no Node with name is in map
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     NamedNodeMap::removeNamedItem(
>     	const unicode * name
>     );

> ### Method: NamedNodeMap::item

>     //=========================================================================
>     // Method:	item
>     // Desc:	Returns the "index"th item in the map. If the index is greater
>     //			than or equal to the number of nodes in the map, this returns
>     //			null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     NamedNodeMap::item(
>     	int index                                       //Index into the map
>     );

> ### Method: NamedNodeMap::getLength

>     //=========================================================================
>     // Method:	getLength
>     // Desc:	Then number of nodes in the map. The range of valid child node
>     //			indices is 0 to length-1, inclusive.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     NamedNodeMap::getLength(
>     );

## Interface: NodeList

>     /*****************************************************************
>     Interface: NodeList
>     Desc:
>     From the DOM spec:
>     The NodeList interface provides the abstraction of an ordered
>     collection of nodes, without defining or constraining how this collection
>     is implemented.
>     The items in the NodeList are accessible via an integral
>     index, starting from 0.
>     Notes:
>     Non-DOM method: destroy()
>     *****************************************************************/

> ### Method: NodeList::item

>     //=========================================================================
>     // Method:	item
>     // Desc:	Returns the "index"th item in the list. If the index is greater
>     //			than or equal to the number of nodes in the list, this returns
>     //			null.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     Node *
>     NodeList::item(
>     	int index
>     );

> ### Method: NodeList::getLength

>     //=========================================================================
>     // Method:	getLength
>     // Desc:	Then number of nodes in the list. The range of valid child node
>     //			indices is 0 to length-1, inclusive.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     NodeList::getLength(
>     );

> ### Method: NodeList::destroy

>     //=========================================================================
>     // Method:	destroy
>     // Desc:	Delete this NodeList. This must be called when the NodeList
>     //			is no longer needed.
>     //
>     // Notes:	C/C++ extension to DOM level 1
>     //=========================================================================

>     C++ Signature

>     void
>     Node::destroy(
>     );

## Interface: DOMException

>     /*****************************************************************
>     Interface: DOMException
>     Desc:
>     From the DOM spec:
>     DOM operations only raise exceptions in "exceptional" circumstances, i.e.,
>     when an operation is impossible to perform (either for logical reasons,
>     because data is lost, or  because the implementation has become unstable).
>     In general, DOM methods return specific error values in ordinary
>     processing situation, such as out-of-bound errors when using
>     NodeList.
>     Implementations may raise other exceptions under other circumstances.
>     For example, implementations may raise an implementation-dependent
>     exception if a null argument is passed.
>     Some languages and object systems do not support the concept of
>     exceptions. For such systems, error conditions may be indicated using
>     native error reporting mechanisms. For some bindings, for example, methods
>     may return error codes similar to those listed in the corresponding method
>     descriptions.
>     Notes:
>     *****************************************************************/

> ### Method: DOMException::getMessage

>     //=========================================================================
>     // Method:	getMessage
>     // Desc:	Return the text message associated with the exception, if any.
>     //			This may return null if no message was associated with the
>     //			exception.
>     //
>     // Notes:	This is an extension to DOM Level 1.
>     //=========================================================================

>     C++ Signature

>     const unicode *
>     DOMException::getMessage(
>     );

> ### Method: DOMException::getCode

>     //=========================================================================
>     // Method:	getCode
>     // Desc:	Get the DOM-defined exception code associated with this
>     //			exception.
>     //
>     // Notes:
>     //=========================================================================

>     C++ Signature

>     int
>     DOMException::getCode(
>     );

> ### Method: DOMException::destroy

>     //=========================================================================
>     // Method:	destroy
>     // Desc:	Delete this exception.
>     //
>     // Notes:	C/C++ extension to DOM level 1
>     //=========================================================================

>     C++ Signature

>     void
>     DOMException::destroy(
>     );