/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* * This file is available under and governed by the GNU General Public * License version 2 only, as published by the Free Software Foundation. * However, the following notice accompanied the original version of this * file and, per its terms, should not be removed: * * Copyright (c) 2004 World Wide Web Consortium, * * (Massachusetts Institute of Technology, European Research Consortium for * Informatics and Mathematics, Keio University). All Rights Reserved. This * work is distributed under the W3C(r) Software License [1] in the hope that * it will be useful, but WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 */ package org.w3c.dom; /** * 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. *

The values of nodeName, * nodeValue, and attributes vary according to the * node type as follows: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
InterfacenodeNamenodeValueattributes
* Attrsame as Attr.namesame as * Attr.valuenull
CDATASection * "#cdata-section"same as CharacterData.data, the * content of the CDATA Sectionnull
Comment * "#comment"same as CharacterData.data, the * content of the commentnull
Document * "#document"nullnull
* DocumentFragment"#document-fragment" * nullnull
DocumentTypesame as * DocumentType.namenullnull
* Elementsame as Element.tagNamenull * NamedNodeMap
Entityentity namenull * null
EntityReferencename of entity referenced * nullnull
Notationnotation name * nullnull
ProcessingInstructionsame * as ProcessingInstruction.targetsame as * ProcessingInstruction.datanull
Text * "#text"same as CharacterData.data, the content * of the text nodenull
*

See also the Document Object Model (DOM) Level 3 Core Specification. */ public interface Node { // NodeType /** * The node is an Element. */ public static final short ELEMENT_NODE = 1; /** * The node is an Attr. */ public static final short ATTRIBUTE_NODE = 2; /** * The node is a Text node. */ public static final short TEXT_NODE = 3; /** * The node is a CDATASection. */ public static final short CDATA_SECTION_NODE = 4; /** * The node is an EntityReference. */ public static final short ENTITY_REFERENCE_NODE = 5; /** * The node is an Entity. */ public static final short ENTITY_NODE = 6; /** * The node is a ProcessingInstruction. */ public static final short PROCESSING_INSTRUCTION_NODE = 7; /** * The node is a Comment. */ public static final short COMMENT_NODE = 8; /** * The node is a Document. */ public static final short DOCUMENT_NODE = 9; /** * The node is a DocumentType. */ public static final short DOCUMENT_TYPE_NODE = 10; /** * The node is a DocumentFragment. */ public static final short DOCUMENT_FRAGMENT_NODE = 11; /** * The node is a Notation. */ public static final short NOTATION_NODE = 12; /** * The name of this node, depending on its type; see the table above. */ public String getNodeName(); /** * 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, * including if the node is read-only. * @exception DOMException * DOMSTRING_SIZE_ERR: Raised when it would return more characters than * fit in a DOMString variable on the implementation * platform. */ public String getNodeValue() throws 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, * including if the node is read-only. * @exception DOMException * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly and if * it is not defined to be null. */ public void setNodeValue(String nodeValue) throws DOMException; /** * A code representing the type of the underlying object, as defined above. */ public short getNodeType(); /** * 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. */ public Node getParentNode(); /** * A NodeList that contains all children of this node. If * there are no children, this is a NodeList containing no * nodes. */ public NodeList getChildNodes(); /** * The first child of this node. If there is no such node, this returns * null. */ public Node getFirstChild(); /** * The last child of this node. If there is no such node, this returns * null. */ public Node getLastChild(); /** * The node immediately preceding this node. If there is no such node, * this returns null. */ public Node getPreviousSibling(); /** * The node immediately following this node. If there is no such node, * this returns null. */ public Node getNextSibling(); /** * A NamedNodeMap containing the attributes of this node (if * it is an Element) or null otherwise. */ public NamedNodeMap getAttributes(); /** * 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. * * @since DOM Level 2 */ public Document getOwnerDocument(); /** * 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. *

Note: Inserting a node before itself is implementation * dependent. * @param newChild The node to insert. * @param refChild The reference node, i.e., the node before which the * new node must be inserted. * @return The node being inserted. * @exception DOMException * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not * allow children of the type of the newChild node, or if * the node to insert is one of this node's ancestors or this node * itself, or if this node is of type Document and the * DOM application attempts to insert a second * DocumentType or Element node. *
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. *
NOT_SUPPORTED_ERR: if this node is of type Document, * this exception might be raised if the DOM implementation doesn't * support the insertion of a DocumentType or * Element node. * * @since DOM Level 3 */ public Node insertBefore(Node newChild, Node refChild) throws 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. *

Note: Replacing a node with itself is implementation * dependent. * @param newChild The new node to put in the child list. * @param oldChild The node being replaced in the list. * @return The node replaced. * @exception DOMException * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not * allow children of the type of the newChild node, or if * the node to put in is one of this node's ancestors or this node * itself, or if this node is of type Document and the * result of the replacement operation would add a second * DocumentType or Element on the * Document node. *
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. *
NOT_SUPPORTED_ERR: if this node is of type Document, * this exception might be raised if the DOM implementation doesn't * support the replacement of the DocumentType child or * Element child. * * @since DOM Level 3 */ public Node replaceChild(Node newChild, Node oldChild) throws DOMException; /** * Removes the child node indicated by oldChild from the list * of children, and returns it. * @param oldChild The node being removed. * @return The node removed. * @exception DOMException * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. *
NOT_FOUND_ERR: Raised if oldChild is not a child of * this node. *
NOT_SUPPORTED_ERR: if this node is of type Document, * this exception might be raised if the DOM implementation doesn't * support the removal of the DocumentType child or the * Element child. * * @since DOM Level 3 */ public Node removeChild(Node oldChild) throws 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. * @param 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 * @return The node added. * @exception DOMException * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not * allow children of the type of the newChild node, or if * the node to append is one of this node's ancestors or this node * itself, or if this node is of type Document and the * DOM application attempts to append a second * DocumentType or Element node. *
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. *
NOT_SUPPORTED_ERR: if the newChild node is a child * of the Document node, this exception might be raised * if the DOM implementation doesn't support the removal of the * DocumentType child or Element child. * * @since DOM Level 3 */ public Node appendChild(Node newChild) throws DOMException; /** * Returns whether this node has any children. * @return Returns true if this node has any children, * false otherwise. */ public boolean hasChildNodes(); /** * 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) and no user data. User * data associated to the imported node is not carried over. However, if * any UserDataHandlers has been specified along with the * associated data these handlers will be called with the appropriate * parameters before this method returns. *
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 children it * contains unless it is a deep clone. This includes text contained in * an the Element since the text is contained in a child * Text node. Cloning an Attr directly, as * opposed to be cloned as part of an Element cloning * operation, returns a specified attribute (specified is * true). Cloning an Attr always clones its * children, since they represent its value, no matter whether this is a * deep clone or not. Cloning an EntityReference * automatically constructs its subtree if a corresponding * Entity is available, no matter whether this is a deep * clone or not. 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. * @param 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). * @return The duplicate node. */ public Node cloneNode(boolean deep); /** * 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 [XPointer] * lookups) that depend on a particular document tree structure are to * be used. If the parameter "normalize-characters" of the * DOMConfiguration object attached to the * Node.ownerDocument is true, this method * will also fully normalize the characters of the Text * nodes. *

Note: 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. * * @since DOM Level 3 */ public void normalize(); /** * Tests whether the DOM implementation implements a specific feature and * that feature is supported by this node, as specified in . * @param feature The name of the feature to test. * @param version This is the version number of the feature to test. * @return Returns true if the specified feature is * supported on this node, false otherwise. * * @since DOM Level 2 */ public boolean isSupported(String feature, String version); /** * The namespace URI of this node, or null if it is * unspecified (see ). *
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 Document.createElement(), this is always * null. *

Note: Per the Namespaces in XML Specification [XML Namespaces] * an attribute does not inherit its namespace from the element it is * attached to. If an attribute is not explicitly given a namespace, it * simply has no namespace. * * @since DOM Level 2 */ public String getNamespaceURI(); /** * The namespace prefix of this node, or null if it is * unspecified. When it is defined to be null, setting it * has no effect, including if the node is read-only. *
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. *
Setting the prefix to null makes it unspecified, * setting it to an empty string is implementation dependent. *
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. * * @since DOM Level 2 */ public String getPrefix(); /** * The namespace prefix of this node, or null if it is * unspecified. When it is defined to be null, setting it * has no effect, including if the node is read-only. *
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. *
Setting the prefix to null makes it unspecified, * setting it to an empty string is implementation dependent. *
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. * @exception DOMException * INVALID_CHARACTER_ERR: Raised if the specified prefix contains an * illegal character according to the XML version in use specified in * the Document.xmlVersion attribute. *
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" [XML Namespaces] * . * * @since DOM Level 2 */ public void setPrefix(String prefix) throws DOMException; /** * 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 Document.createElement(), this is always * null. * * @since DOM Level 2 */ public String getLocalName(); /** * Returns whether this node (if it is an element) has any attributes. * @return Returns true if this node has any attributes, * false otherwise. * * @since DOM Level 2 */ public boolean hasAttributes(); /** * The absolute base URI of this node or null if the * implementation wasn't able to obtain an absolute URI. This value is * computed as described in . However, when the Document * supports the feature "HTML" [DOM Level 2 HTML] * , the base URI is computed using first the value of the href * attribute of the HTML BASE element if any, and the value of the * documentURI attribute from the Document * interface otherwise. * * @since DOM Level 3 */ public String getBaseURI(); // DocumentPosition /** * The two nodes are disconnected. Order between disconnected nodes is * always implementation-specific. */ public static final short DOCUMENT_POSITION_DISCONNECTED = 0x01; /** * The second node precedes the reference node. */ public static final short DOCUMENT_POSITION_PRECEDING = 0x02; /** * The node follows the reference node. */ public static final short DOCUMENT_POSITION_FOLLOWING = 0x04; /** * The node contains the reference node. A node which contains is always * preceding, too. */ public static final short DOCUMENT_POSITION_CONTAINS = 0x08; /** * The node is contained by the reference node. A node which is contained * is always following, too. */ public static final short DOCUMENT_POSITION_CONTAINED_BY = 0x10; /** * The determination of preceding versus following is * implementation-specific. */ public static final short DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20; /** * Compares the reference node, i.e. the node on which this method is * being called, with a node, i.e. the one passed as a parameter, with * regard to their position in the document and according to the * document order. * @param other The node to compare against the reference node. * @return Returns how the node is positioned relatively to the reference * node. * @exception DOMException * NOT_SUPPORTED_ERR: when the compared nodes are from different DOM * implementations that do not coordinate to return consistent * implementation-specific results. * * @since DOM Level 3 */ public short compareDocumentPosition(Node other) throws DOMException; /** * This attribute returns the text content of this node and its * descendants. When it is defined to be null, setting it * has no effect. On setting, any possible children this node may have * are removed and, if it the new string is not empty or * null, replaced by a single Text node * containing the string this attribute is set to. *
On getting, no serialization is performed, the returned string * does not contain any markup. No whitespace normalization is performed * and the returned string does not contain the white spaces in element * content (see the attribute * Text.isElementContentWhitespace). Similarly, on setting, * no parsing is performed either, the input string is taken as pure * textual content. *
The string returned is made of the text content of this node * depending on its type, as defined below: * * * * * * * * * * * * * * * * * *
Node typeContent
* ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, * DOCUMENT_FRAGMENT_NODEconcatenation of the textContent * attribute value of every child node, excluding COMMENT_NODE and * PROCESSING_INSTRUCTION_NODE nodes. This is the empty string if the * node has no children.
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, * PROCESSING_INSTRUCTION_NODEnodeValue
DOCUMENT_NODE, * DOCUMENT_TYPE_NODE, NOTATION_NODEnull
* @exception DOMException * DOMSTRING_SIZE_ERR: Raised when it would return more characters than * fit in a DOMString variable on the implementation * platform. * * @since DOM Level 3 */ public String getTextContent() throws DOMException; /** * This attribute returns the text content of this node and its * descendants. When it is defined to be null, setting it * has no effect. On setting, any possible children this node may have * are removed and, if it the new string is not empty or * null, replaced by a single Text node * containing the string this attribute is set to. *
On getting, no serialization is performed, the returned string * does not contain any markup. No whitespace normalization is performed * and the returned string does not contain the white spaces in element * content (see the attribute * Text.isElementContentWhitespace). Similarly, on setting, * no parsing is performed either, the input string is taken as pure * textual content. *
The string returned is made of the text content of this node * depending on its type, as defined below: * * * * * * * * * * * * * * * * * *
Node typeContent
* ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, * DOCUMENT_FRAGMENT_NODEconcatenation of the textContent * attribute value of every child node, excluding COMMENT_NODE and * PROCESSING_INSTRUCTION_NODE nodes. This is the empty string if the * node has no children.
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE, * PROCESSING_INSTRUCTION_NODEnodeValue
DOCUMENT_NODE, * DOCUMENT_TYPE_NODE, NOTATION_NODEnull
* @exception DOMException * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly. * * @since DOM Level 3 */ public void setTextContent(String textContent) throws DOMException; /** * Returns whether this node is the same node as the given one. *
This method provides a way to determine whether two * Node references returned by the implementation reference * the same object. When two Node references are references * to the same object, even if through a proxy, the references may be * used completely interchangeably, such that all attributes have the * same values and calling the same DOM method on either reference * always has exactly the same effect. * @param other The node to test against. * @return Returns true if the nodes are the same, * false otherwise. * * @since DOM Level 3 */ public boolean isSameNode(Node other); /** * Look up the prefix associated to the given namespace URI, starting from * this node. The default namespace declarations are ignored by this * method. *
See for details on the algorithm used by this method. * @param namespaceURI The namespace URI to look for. * @return Returns an associated namespace prefix if found or * null if none is found. If more than one prefix are * associated to the namespace prefix, the returned namespace prefix * is implementation dependent. * * @since DOM Level 3 */ public String lookupPrefix(String namespaceURI); /** * This method checks if the specified namespaceURI is the * default namespace or not. * @param namespaceURI The namespace URI to look for. * @return Returns true if the specified * namespaceURI is the default namespace, * false otherwise. * * @since DOM Level 3 */ public boolean isDefaultNamespace(String namespaceURI); /** * Look up the namespace URI associated to the given prefix, starting from * this node. *
See for details on the algorithm used by this method. * @param prefix The prefix to look for. If this parameter is * null, the method will return the default namespace URI * if any. * @return Returns the associated namespace URI or null if * none is found. * * @since DOM Level 3 */ public String lookupNamespaceURI(String prefix); /** * Tests whether two nodes are equal. *
This method tests for equality of nodes, not sameness (i.e., * whether the two nodes are references to the same object) which can be * tested with Node.isSameNode(). All nodes that are the * same will also be equal, though the reverse may not be true. *
Two nodes are equal if and only if the following conditions are * satisfied: *

*
For two DocumentType nodes to be equal, the following * conditions must also be satisfied: * *
On the other hand, the following do not affect equality: the * ownerDocument, baseURI, and * parentNode attributes, the specified * attribute for Attr nodes, the schemaTypeInfo * attribute for Attr and Element nodes, the * Text.isElementContentWhitespace attribute for * Text nodes, as well as any user data or event listeners * registered on the nodes. *

Note: As a general rule, anything not mentioned in the * description above is not significant in consideration of equality * checking. Note that future versions of this specification may take * into account more attributes and implementations conform to this * specification are expected to be updated accordingly. * @param arg The node to compare equality with. * @return Returns true if the nodes are equal, * false otherwise. * * @since DOM Level 3 */ public boolean isEqualNode(Node arg); /** * This method returns a specialized object which implements the * specialized APIs of the specified feature and version, as specified * in . The specialized object may also be obtained by using * binding-specific casting methods but is not necessarily expected to, * as discussed in . This method also allow the implementation to * provide specialized objects which do not support the Node * interface. * @param feature The name of the feature requested. Note that any plus * sign "+" prepended to the name of the feature will be ignored since * it is not significant in the context of this method. * @param version This is the version number of the feature to test. * @return Returns an object which implements the specialized APIs of * the specified feature and version, if any, or null if * there is no object which implements interfaces associated with that * feature. If the DOMObject returned by this method * implements the Node interface, it must delegate to the * primary core Node and not return results inconsistent * with the primary core Node such as attributes, * childNodes, etc. * * @since DOM Level 3 */ public Object getFeature(String feature, String version); /** * Associate an object to a key on this node. The object can later be * retrieved from this node by calling getUserData with the * same key. * @param key The key to associate the object to. * @param data The object to associate to the given key, or * null to remove any existing association to that key. * @param handler The handler to associate to that key, or * null. * @return Returns the DOMUserData previously associated to * the given key on this node, or null if there was none. * * @since DOM Level 3 */ public Object setUserData(String key, Object data, UserDataHandler handler); /** * Retrieves the object associated to a key on a this node. The object * must first have been set to this node by calling * setUserData with the same key. * @param key The key the object is associated to. * @return Returns the DOMUserData associated to the given * key on this node, or null if there was none. * * @since DOM Level 3 */ public Object getUserData(String key); }