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 DOMObject 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) {
+ return getOwnerDocument().setUserData( key, data, 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 DOMObject associated to the given key
+ * on this node, or null if there was none.
+ * @since DOM Level 3
+ */
+ public Object getUserData(String key) {
+ return getOwnerDocument().getUserData( key);
+ }
+
+ /**
+ * This method returns a specialized object which implements the
+ * specialized APIs of the specified feature and version. The
+ * specialized object may also be obtained by using binding-specific
+ * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
+ * @param feature The name of the feature requested (case-insensitive).
+ * @param version This is the version number of the feature to test. If
+ * the version is null or the empty string, supporting
+ * any version of the feature will cause the method to return an
+ * object that supports at least one version of the feature.
+ * @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) {
+ // we don't have any alternate node, either this node does the job
+ // or we don't have anything that does
+ return isSupported(feature, version) ? this : null;
+ }
+
+ /**
+ * Tests whether two nodes are equal.
+ * Node.isSameNode. All nodes that are the same
+ * will also be equal, though the reverse may not be true.
+ * nodeName, localName,
+ * namespaceURI, prefix, nodeValue
+ * , baseURI. This is: they are both null, or
+ * they have the same length and are character for character identical.
+ * The attributes NamedNodeMaps are equal.
+ * This is: they are both null, or they have the same
+ * length and for each node that exists in one map there is a node that
+ * exists in the other map and is equal, although not necessarily at the
+ * same index.The childNodes NodeLists are
+ * equal. This is: they are both null, or they have the
+ * same length and contain equal nodes at the same index. This is true
+ * for Attr nodes as for any other type of node. Note that
+ * normalization can affect equality; to avoid this, nodes should be
+ * normalized before being compared.
+ * DocumentType nodes to be equal, the following
+ * conditions must also be satisfied: The following string attributes
+ * are equal: publicId, systemId,
+ * internalSubset.The entities
+ * NamedNodeMaps are equal.The notations
+ * NamedNodeMaps are equal.
+ * ownerDocument attribute, the specified
+ * attribute for Attr nodes, the
+ * isWhitespaceInElementContent attribute for
+ * Text nodes, as well as any user data or event listeners
+ * registered on the nodes.
+ * @param arg The node to compare equality with.
+ * @param deep If true, recursively compare the subtrees; if
+ * false, compare only the nodes themselves (and its
+ * attributes, if it is an Element).
+ * @return If the nodes, and possibly subtrees are equal,
+ * true otherwise false.
+ * @since DOM Level 3
+ */
+ public boolean isEqualNode(Node arg) {
+ if (arg == this) {
+ return true;
+ }
+ if (arg.getNodeType() != getNodeType()) {
+ return false;
+ }
+ // in theory nodeName can't be null but better be careful
+ // who knows what other implementations may be doing?...
+ if (getNodeName() == null) {
+ if (arg.getNodeName() != null) {
+ return false;
+ }
+ }
+ else if (!getNodeName().equals(arg.getNodeName())) {
+ return false;
+ }
+
+ if (getLocalName() == null) {
+ if (arg.getLocalName() != null) {
+ return false;
+ }
+ }
+ else if (!getLocalName().equals(arg.getLocalName())) {
+ return false;
+ }
+
+ if (getNamespaceURI() == null) {
+ if (arg.getNamespaceURI() != null) {
+ return false;
+ }
+ }
+ else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
+ return false;
+ }
+
+ if (getPrefix() == null) {
+ if (arg.getPrefix() != null) {
+ return false;
+ }
+ }
+ else if (!getPrefix().equals(arg.getPrefix())) {
+ return false;
+ }
+
+ if (getNodeValue() == null) {
+ if (arg.getNodeValue() != null) {
+ return false;
+ }
+ }
+ else if (!getNodeValue().equals(arg.getNodeValue())) {
+ return false;
+ }
+ /*
+ if (getBaseURI() == null) {
+ if (((NodeImpl) arg).getBaseURI() != null) {
+ return false;
+ }
+ }
+ else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
+ return false;
+ }
+*/
+
+ return true;
+ }
+
+ /**
+ * DOM Level 3 - Experimental:
+ * Look up the namespace URI associated to the given prefix, starting from this node.
+ * Use lookupNamespaceURI(null) to lookup the default namespace
+ *
+ * @param namespaceURI
+ * @return th URI for the namespace
+ * @since DOM Level 3
+ */
+ public String lookupNamespaceURI(String specifiedPrefix) {
+ short type = this.getNodeType();
+ switch (type) {
+ case Node.ELEMENT_NODE : {
+
+ String namespace = this.getNamespaceURI();
+ String prefix = this.getPrefix();
+ if (namespace !=null) {
+ // REVISIT: is it possible that prefix is empty string?
+ if (specifiedPrefix== null && prefix==specifiedPrefix) {
+ // looking for default namespace
+ return namespace;
+ } else if (prefix != null && prefix.equals(specifiedPrefix)) {
+ // non default namespace
+ return namespace;
+ }
+ }
+ if (this.hasAttributes()) {
+ NamedNodeMap map = this.getAttributes();
+ int length = map.getLength();
+ for (int i=0;itrue if the specified namespaceURI
+ * is the default namespace, false otherwise.
+ * @since DOM Level 3
+ */
+ public boolean isDefaultNamespace(String namespaceURI){
+ /*
+ // REVISIT: remove casts when DOM L3 becomes REC.
+ short type = this.getNodeType();
+ switch (type) {
+ case Node.ELEMENT_NODE: {
+ String namespace = this.getNamespaceURI();
+ String prefix = this.getPrefix();
+
+ // REVISIT: is it possible that prefix is empty string?
+ if (prefix == null || prefix.length() == 0) {
+ if (namespaceURI == null) {
+ return (namespace == namespaceURI);
+ }
+ return namespaceURI.equals(namespace);
+ }
+ if (this.hasAttributes()) {
+ ElementImpl elem = (ElementImpl)this;
+ NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
+ if (attr != null) {
+ String value = attr.getNodeValue();
+ if (namespaceURI == null) {
+ return (namespace == value);
+ }
+ return namespaceURI.equals(value);
+ }
+ }
+
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.isDefaultNamespace(namespaceURI);
+ }
+ return false;
+ }
+ case Node.DOCUMENT_NODE:{
+ return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
+ }
+
+ case Node.ENTITY_NODE :
+ case Node.NOTATION_NODE:
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ case Node.DOCUMENT_TYPE_NODE:
+ // type is unknown
+ return false;
+ case Node.ATTRIBUTE_NODE:{
+ if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
+ return ownerNode.isDefaultNamespace(namespaceURI);
+
+ }
+ return false;
+ }
+ default:{
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.isDefaultNamespace(namespaceURI);
+ }
+ return false;
+ }
+
+ }
+*/
+ return false;
+
+
+ }
+
+ /**
+ *
+ * DOM Level 3 - Experimental:
+ * Look up the prefix associated to the given namespace URI, starting from this node.
+ *
+ * @param namespaceURI
+ * @return the prefix for the namespace
+ */
+ public String lookupPrefix(String namespaceURI){
+
+ // REVISIT: When Namespaces 1.1 comes out this may not be true
+ // Prefix can't be bound to null namespace
+ if (namespaceURI == null) {
+ return null;
+ }
+
+ short type = this.getNodeType();
+
+ switch (type) {
+/*
+ case Node.ELEMENT_NODE: {
+
+ String namespace = this.getNamespaceURI(); // to flip out children
+ return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
+ }
+
+ case Node.DOCUMENT_NODE:{
+ return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
+ }
+*/
+ case Node.ENTITY_NODE :
+ case Node.NOTATION_NODE:
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ case Node.DOCUMENT_TYPE_NODE:
+ // type is unknown
+ return null;
+ case Node.ATTRIBUTE_NODE:{
+ if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
+ return getOwnerElement().lookupPrefix(namespaceURI);
+
+ }
+ return null;
+ }
+ default:{
+/*
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.lookupPrefix(namespaceURI);
+ }
+*/
+ return null;
+ }
+ }
+ }
+
+ /**
+ * Returns whether this node is the same node as the given one.
+ * 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 interchangably, 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) {
+ // we do not use any wrapper so the answer is obvious
+ return this == other;
+ }
+
+ /**
+ * This attribute returns the text content of this node and its
+ * descendants. When it is defined to be null, setting it has no effect.
+ * When set, any possible children this node may have are removed and
+ * 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, the returned string does not contain the
+ * element content whitespaces . Similarly, on setting, no parsing is
+ * performed either, the input string is taken as pure textual content.
+ * | Node type | + *Content | + *
|---|---|
| + * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, + * DOCUMENT_FRAGMENT_NODE | + *concatenation of the textContent
+ * attribute value of every child node, excluding COMMENT_NODE and
+ * PROCESSING_INSTRUCTION_NODE nodes |
+ *
| ATTRIBUTE_NODE, TEXT_NODE, + * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE | + *
+ * nodeValue |
+ *
| DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE | + *+ * null | + *
DOMString variable on the implementation
+ * platform.
+ * @since DOM Level 3
+ */
+ public void setTextContent(String textContent)
+ throws DOMException {
+ setNodeValue(textContent);
+ }
+
+ /**
+ * This attribute returns the text content of this node and its
+ * descendants. When it is defined to be null, setting it has no effect.
+ * When set, any possible children this node may have are removed and
+ * 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, the returned string does not contain the
+ * element content whitespaces . Similarly, on setting, no parsing is
+ * performed either, the input string is taken as pure textual content.
+ * | Node type | + *Content | + *
|---|---|
| + * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, + * DOCUMENT_FRAGMENT_NODE | + *concatenation of the textContent
+ * attribute value of every child node, excluding COMMENT_NODE and
+ * PROCESSING_INSTRUCTION_NODE nodes |
+ *
| ATTRIBUTE_NODE, TEXT_NODE, + * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE | + *
+ * nodeValue |
+ *
| DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE | + *+ * null | + *
DOMString variable on the implementation
+ * platform.
+ * @since DOM Level 3
+ */
+ public String getTextContent() throws DOMException {
+ return getNodeValue(); // overriden in some subclasses
+ }
+
+ /**
+ * Compares a node with this node with regard to their position in the
+ * document.
+ * @param other The node to compare against this node.
+ * @return Returns how the given node is positioned relatively to this
+ * node.
+ * @since DOM Level 3
+ */
+ public short compareDocumentPosition(Node other) throws DOMException {
+ return 0;
+ }
+
+ /**
+ * The absolute base URI of this node or null if undefined.
+ * This value is computed according to . However, when the
+ * Document supports the feature "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.
+ * Element, a Document
+ * or a a ProcessingInstruction, this attribute represents
+ * the properties [base URI] defined in . When the node is a
+ * Notation, an Entity, or an
+ * EntityReference, this attribute represents the
+ * properties [declaration base URI] in the . How will this be affected
+ * by resolution of relative namespace URIs issue?It's not.Should this
+ * only be on Document, Element, ProcessingInstruction, Entity, and
+ * Notation nodes, according to the infoset? If not, what is it equal to
+ * on other nodes? Null? An empty string? I think it should be the
+ * parent's.No.Should this be read-only and computed or and actual
+ * read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
+ * teleconference 30 May 2001).If the base HTML element is not yet
+ * attached to a document, does the insert change the Document.baseURI?
+ * Yes. (F2F 26 Sep 2001)
+ * @since DOM Level 3
+ */
+ public String getBaseURI() {
+ return null;
+ }
+}