awt/javax/imageio/metadata/IIOMetadataNode.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package javax.imageio.metadata;

import java.util.ArrayList;
import java.util.List;

import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

//???AWT
//import org.w3c.dom.TypeInfo;
//import org.w3c.dom.UserDataHandler;

/**
 * The Class IIOMetadataNode represents a node of the (DOM-style) metadata tree.
 * 
 * @since Android 1.0
 */
public class IIOMetadataNode implements Element, NodeList {

    /**
     * The node name.
     */
    private String nodeName;

    /**
     * The node value.
     */
    private String nodeValue;

    /**
     * The attributes.
     */
    private IIOMetadataNodeList attrs = new IIOMetadataNodeList(new ArrayList<IIOMetadataNode>());

    /**
     * The parent node.
     */
    private IIOMetadataNode parent;

    /**
     * The first child node.
     */
    private IIOMetadataNode firstChild;

    /**
     * The last child node.
     */
    private IIOMetadataNode lastChild;

    /**
     * The previous sibling.
     */
    private IIOMetadataNode previousSibling;

    /**
     * The next sibling.
     */
    private IIOMetadataNode nextSibling;

    /**
     * The number of children.
     */
    private int nChildren;

    /**
     * The user object associated with this node.
     */
    private Object userObject;

    /**
     * The text content of this node.
     */
    private String textContent;

    /**
     * Instantiates a new empty node.
     */
    public IIOMetadataNode() {
    }

    /**
     * Instantiates a new empty node with the specified name.
     * 
     * @param nodeName
     *            the node name.
     */
    public IIOMetadataNode(String nodeName) {
        this.nodeName = nodeName;
    }

    /**
     * Instantiates a new IIOMetadataNode with the specified name and value.
     * 
     * @param nodeName
     *            the node name.
     * @param nodeValue
     *            the node value.
     */
    private IIOMetadataNode(String nodeName, String nodeValue) {
        this.nodeName = nodeName;
        this.nodeValue = nodeValue;
    }

    public String getTagName() {
        return nodeName;
    }

    public String getAttribute(String name) {
        Attr attrNode = (Attr)attrs.getNamedItem(name);
        return (attrNode == null) ? "" : attrNode.getValue();
    }

    public void setAttribute(String name, String value) throws DOMException {
        Attr attr = (Attr)attrs.getNamedItem(name);
        if (attr != null) {
            attr.setValue(value);
        } else {
            attrs.list.add(new IIOMetadataAttr(name, value, this));
        }
    }

    public void removeAttribute(String name) throws DOMException {
        IIOMetadataAttr attr = (IIOMetadataAttr)attrs.getNamedItem(name);
        if (attr != null) {
            attr.setOwnerElement(null);
            attrs.list.remove(attr);
        }
    }

    public Attr getAttributeNode(String name) {
        return (Attr)attrs.getNamedItem(name);
    }

    public Attr setAttributeNode(Attr newAttr) throws DOMException {
        // Check if this attribute is already in use.
        Element owner = newAttr.getOwnerElement();
        if (owner != null) {
            if (owner == this) { // Replacing an attribute node by itself has no
                // effect
                return null;
            } else {
                throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR,
                        "Attribute is already in use");
            }
        }

        String name = newAttr.getName();
        Attr oldAttr = getAttributeNode(name);
        if (oldAttr != null) {
            removeAttributeNode(oldAttr);
        }

        IIOMetadataAttr iioAttr;
        if (newAttr instanceof IIOMetadataAttr) {
            iioAttr = (IIOMetadataAttr)newAttr;
            iioAttr.setOwnerElement(this);
        } else {
            iioAttr = new IIOMetadataAttr(name, newAttr.getValue(), this);
        }

        attrs.list.add(iioAttr);

        return oldAttr;
    }

    public Attr removeAttributeNode(Attr oldAttr) throws DOMException {
        if (!attrs.list.remove(oldAttr)) { // Not found
            throw new DOMException(DOMException.NOT_FOUND_ERR, "No such attribute!");
        }

        ((IIOMetadataAttr)oldAttr).setOwnerElement(null);

        return oldAttr;
    }

    public NodeList getElementsByTagName(String name) {
        ArrayList<IIOMetadataNode> nodes = new ArrayList<IIOMetadataNode>();

        // Non-recursive tree walk
        Node pos = this;

        while (pos != null) {
            if (pos.getNodeName().equals(name)) {
                nodes.add((IIOMetadataNode)pos);
            }

            Node nextNode = pos.getFirstChild();

            while (nextNode == null) {
                if (pos == this) {
                    break;
                }

                nextNode = pos.getNextSibling();

                if (nextNode == null) {
                    pos = pos.getParentNode();

                    if (pos == null || pos == this) {
                        nextNode = null;
                        break;
                    }
                }
            }
            pos = nextNode;
        }

        return new IIOMetadataNodeList(nodes);
    }

    public String getAttributeNS(String namespaceURI, String localName) throws DOMException {
        return getAttribute(localName);
    }

    public void setAttributeNS(String namespaceURI, String qualifiedName, String value)
            throws DOMException {
        setAttribute(qualifiedName, value);
    }

    public void removeAttributeNS(String namespaceURI, String localName) throws DOMException {
        removeAttribute(localName);
    }

    public Attr getAttributeNodeNS(String namespaceURI, String localName) throws DOMException {
        return getAttributeNode(localName);
    }

    public Attr setAttributeNodeNS(Attr newAttr) throws DOMException {
        return setAttributeNode(newAttr);
    }

    public NodeList getElementsByTagNameNS(String namespaceURI, String localName)
            throws DOMException {
        return getElementsByTagName(localName);
    }

    public boolean hasAttribute(String name) {
        return attrs.getNamedItem(name) != null;
    }

    public boolean hasAttributeNS(String namespaceURI, String localName) throws DOMException {
        return hasAttribute(localName);
    }

    // ???AWT
    /*
     * public TypeInfo getSchemaTypeInfo() { throw new
     * DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported"); }
     */

    /**
     * <i>Description copied from interface: org.w3c.dom.Element (DOM Level
     * 3)</i>
     * <p>
     * If the parameter isId is true, this method declares the specified
     * attribute to be a user-determined ID attribute . This affects the value
     * of Attr.isId and the behavior of Document.getElementById, but does not
     * change any schema that may be in use, in particular this does not affect
     * the Attr.schemaTypeInfo of the specified Attr node. Use the value false
     * for the parameter isId to undeclare an attribute for being a
     * user-determined ID attribute. To specify an attribute by local name and
     * namespace URI, use the setIdAttributeNS method.
     * </p>
     * 
     * @param name
     *            the name of the attribute.
     * @param isId
     *            the flag which determines whether this attribute is of type
     *            ID.
     * @throws DOMException
     *             if a DOM error occurred while setting the attribute type.
     *             <p>
     *             NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *             <br>
     *             NOT_FOUND_ERR: Raised if the specified node is not an
     *             attribute of this element.
     *             </p>
     */
    public void setIdAttribute(String name, boolean isId) throws DOMException {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Element (DOM Level
     * 3)</i>
     * <p>
     * If the parameter isId is true, this method declares the specified
     * attribute to be a user-determined ID attribute . This affects the value
     * of Attr.isId and the behavior of Document.getElementById, but does not
     * change any schema that may be in use, in particular this does not affect
     * the Attr.schemaTypeInfo of the specified Attr node. Use the value false
     * for the parameter isId to undeclare an attribute for being a
     * user-determined ID attribute.
     * </p>
     * 
     * @param namespaceURI
     *            the namespace URI of the attribute.
     * @param localName
     *            the local name of the attribute.
     * @param isId
     *            the flag which determines whether this attribute is of type
     *            ID.
     * @throws DOMException
     *             if a DOM error occurred while setting the attribute type.
     *             <p>
     *             NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *             <br>
     *             NOT_FOUND_ERR: Raised if the specified node is not an
     *             attribute of this element.
     *             </p>
     */
    public void setIdAttributeNS(String namespaceURI, String localName, boolean isId)
            throws DOMException {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Element (DOM Level
     * 3)</i>
     * <p>
     * If the parameter isId is true, this method declares the specified
     * attribute to be a user-determined ID attribute . This affects the value
     * of Attr.isId and the behavior of Document.getElementById, but does not
     * change any schema that may be in use, in particular this does not affect
     * the Attr.schemaTypeInfo of the specified Attr node. Use the value false
     * for the parameter isId to undeclare an attribute for being a
     * user-determined ID attribute.
     * </p>
     * 
     * @param idAttr
     *            the attribute node.
     * @param isId
     *            the flag which determines whether this attribute is of type
     *            ID.
     * @throws DOMException
     *             if a DOM error occurred while setting the attribute type.
     *             <p>
     *             NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *             <br>
     *             NOT_FOUND_ERR: Raised if the specified node is not an
     *             attribute of this element.
     *             </p>
     */
    public void setIdAttributeNode(Attr idAttr, boolean isId) throws DOMException {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    public String getNodeName() {
        return nodeName;
    }

    public String getNodeValue() throws DOMException {
        return nodeValue;
    }

    public void setNodeValue(String nodeValue) throws DOMException {
        this.nodeValue = nodeValue;
    }

    public short getNodeType() {
        return ELEMENT_NODE;
    }

    public Node getParentNode() {
        return parent;
    }

    public NodeList getChildNodes() {
        return this;
    }

    public Node getFirstChild() {
        return firstChild;
    }

    public Node getLastChild() {
        return lastChild;
    }

    public Node getPreviousSibling() {
        return previousSibling;
    }

    public Node getNextSibling() {
        return nextSibling;
    }

    public NamedNodeMap getAttributes() {
        return attrs;
    }

    public Document getOwnerDocument() {
        return null;
    }

    public Node insertBefore(Node newChild, Node refChild) throws DOMException {
        if (newChild == null) {
            throw new IllegalArgumentException("newChild == null!");
        }

        IIOMetadataNode newIIOChild = (IIOMetadataNode)newChild;
        IIOMetadataNode refIIOChild = (IIOMetadataNode)refChild;

        newIIOChild.parent = this;

        if (refIIOChild == null) {
            newIIOChild.nextSibling = null;
            newIIOChild.previousSibling = lastChild;

            // Fix this node
            lastChild = newIIOChild;
            if (firstChild == null) {
                firstChild = newIIOChild;
            }
        } else {
            newIIOChild.nextSibling = refIIOChild;
            newIIOChild.previousSibling = refIIOChild.previousSibling;

            // Fix this node
            if (firstChild == refIIOChild) {
                firstChild = newIIOChild;
            }

            // Fix next node
            if (refIIOChild != null) {
                refIIOChild.previousSibling = newIIOChild;
            }
        }

        // Fix prev node
        if (newIIOChild.previousSibling != null) {
            newIIOChild.previousSibling.nextSibling = newIIOChild;
        }

        nChildren++;

        return newIIOChild;
    }

    public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
        if (newChild == null) {
            throw new IllegalArgumentException("newChild == null!");
        }

        IIOMetadataNode newIIOChild = (IIOMetadataNode)newChild;
        IIOMetadataNode oldIIOChild = (IIOMetadataNode)oldChild;

        IIOMetadataNode next = oldIIOChild.nextSibling;
        IIOMetadataNode previous = oldIIOChild.previousSibling;

        // Fix new node
        newIIOChild.parent = this;
        newIIOChild.nextSibling = next;
        newIIOChild.previousSibling = previous;

        // Fix this node
        if (lastChild == oldIIOChild) {
            lastChild = newIIOChild;
        }
        if (firstChild == oldIIOChild) {
            firstChild = newIIOChild;
        }

        // Fix siblings
        if (next != null) {
            next.previousSibling = newIIOChild;
        }
        if (previous != null) {
            previous.nextSibling = newIIOChild;
        }

        // Fix old child
        oldIIOChild.parent = null;
        oldIIOChild.nextSibling = next;
        oldIIOChild.previousSibling = previous;

        return oldIIOChild;
    }

    public Node removeChild(Node oldChild) throws DOMException {
        if (oldChild == null) {
            throw new IllegalArgumentException("oldChild == null!");
        }

        IIOMetadataNode oldIIOChild = (IIOMetadataNode)oldChild;

        // Fix next and previous
        IIOMetadataNode previous = oldIIOChild.previousSibling;
        IIOMetadataNode next = oldIIOChild.nextSibling;

        if (previous != null) {
            previous.nextSibling = next;
        }
        if (next != null) {
            next.previousSibling = previous;
        }

        // Fix this node
        if (lastChild == oldIIOChild) {
            lastChild = previous;
        }
        if (firstChild == oldIIOChild) {
            firstChild = next;
        }
        nChildren--;

        // Fix old child
        oldIIOChild.parent = null;
        oldIIOChild.previousSibling = null;
        oldIIOChild.nextSibling = null;

        return oldIIOChild;
    }

    public Node appendChild(Node newChild) throws DOMException {
        return insertBefore(newChild, null);
    }

    public boolean hasChildNodes() {
        return nChildren != 0;
    }

    public Node cloneNode(boolean deep) {
        IIOMetadataNode cloned = new IIOMetadataNode(nodeName);
        cloned.setUserObject(getUserObject());

        if (deep) { // Clone recursively
            IIOMetadataNode c = firstChild;
            while (c != null) {
                cloned.insertBefore(c.cloneNode(true), null);
                c = c.nextSibling;
            }
        }

        return cloned; // To change body of implemented methods use File |
        // Settings | File Templates.
    }

    public void normalize() {
        // Do nothing
    }

    public boolean isSupported(String feature, String version) {
        return false;
    }

    public String getNamespaceURI() {
        return null;
    }

    public String getPrefix() {
        return null;
    }

    public void setPrefix(String prefix) throws DOMException {
        // Do nothing
    }

    public String getLocalName() {
        return nodeName;
    }

    public boolean hasAttributes() {
        return attrs.list.size() > 0;
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @return the string representation of the absolute base URI.
     */
    public String getBaseURI() {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @param other
     *            the node to compare against the reference node.
     * @return Returns how the node is positioned relatively to the reference
     *         node.
     * @throws DOMException
     *             NOT_SUPPORTED_ERR: when the compared nodes are from different
     *             DOM implementations that do not coordinate to return
     *             consistent implementation-specific results.
     */
    public short compareDocumentPosition(Node other) throws DOMException {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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:
     * <table>
     * <tr>
     * <td><strong>Node type</strong></td>
     * <td><strong>Content</strong></td>
     * </tr>
     * <tr>
     * <td>ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
     * DOCUMENT_FRAGMENT_NODE</td>
     * <td>concatenation 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.</td>
     * </tr>
     * <tr>
     * <td>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE,
     * PROCESSING_INSTRUCTION_NODE</td>
     * <td>nodeValue</td>
     * </tr>
     * <tr>
     * <td>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
     * <td>null</td>
     * </tr>
     * </table>
     * </p>
     * 
     * @return the text content depending on the type of this node.
     * @throws DOMException
     *             DOMSTRING_SIZE_ERR: Raised when it would return more
     *             characters than fit in a DOMString variable on the
     *             implementation platform.
     */
    public String getTextContent() throws DOMException {
        return textContent;
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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:
     * <table>
     * <tr>
     * <td><strong>Node type</strong></td>
     * <td><strong>Content</strong></td>
     * </tr>
     * <tr>
     * <td>ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
     * DOCUMENT_FRAGMENT_NODE</td>
     * <td>concatenation 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.</td>
     * </tr>
     * <tr>
     * <td>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE,
     * PROCESSING_INSTRUCTION_NODE</td>
     * <td>nodeValue</td>
     * </tr>
     * <tr>
     * <td>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
     * <td>null</td>
     * </tr>
     * </table>
     * </p>
     * 
     * @param textContent
     *            the text content for this node.
     * @throws DOMException
     *             NO_MODIFICATION_ALLOWED_ERR: Raised when the node is
     *             readonly.
     */
    public void setTextContent(String textContent) throws DOMException {
        this.textContent = textContent;
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @param other
     *            the node to test against.
     * @return true, if the nodes are the same, false otherwise.
     */
    public boolean isSameNode(Node other) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @param namespaceURI
     *            the namespace URI to look for.
     * @return the 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.
     */
    public String lookupPrefix(String namespaceURI) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * This method checks if the specified namespaceURI is the default namespace
     * or not.
     * </p>
     * 
     * @param namespaceURI
     *            the namespace URI to look for.
     * @return true, if the specified namespaceURI is the default namespace,
     *         false otherwise.
     */
    public boolean isDefaultNamespace(String namespaceURI) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * Look up the namespace URI associated to the given prefix, starting from
     * this node. See for details on the algorithm used by this method.
     * </p>
     * 
     * @param prefix
     *            the prefix to look for. If this parameter is null, the method
     *            will return the default namespace URI if any.
     * @return the associated namespace URI or null if none is found.
     */
    public String lookupNamespaceURI(String prefix) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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:
     * <p>
     * <li>The two nodes are of the same type.</li>
     * <li>The following string attributes are equal: nodeName, localName,
     * namespaceURI, prefix, nodeValue . This is: they are both null, or they
     * have the same length and are character for character identical.</li>
     * <li>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.</li>
     * <li>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. Note
     * that normalization can affect equality; to avoid this, nodes should be
     * normalized before being compared.</li>
     * </p>
     * For two DocumentType nodes to be equal, the following conditions must
     * also be satisfied:
     * <p>
     * <li>The following string attributes are equal: publicId, systemId,
     * internalSubset.</li>
     * <li>The entities NamedNodeMaps are equal.</li>
     * <li>The notations NamedNodeMaps are equal.</li>
     * </p>
     * 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. </p>
     * <p>
     * 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.
     * </p>
     * 
     * @param arg
     *            the node to compare equality with.
     * @return true, if the nodes are equal, false otherwise.
     */
    public boolean isEqualNode(Node arg) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @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 the 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.
     */
    public Object getFeature(String feature, String version) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    // ???AWT
    /*
     * public Object setUserData(String key, Object data, UserDataHandler
     * handler) { throw new DOMException(DOMException.NOT_SUPPORTED_ERR,
     * "Method not supported"); }
     */

    /**
     * <i>Description copied from interface: org.w3c.dom.Node (DOM Level 3)</i>
     * <p>
     * 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.
     * </p>
     * 
     * @param key
     *            the key the object is associated to.
     * @return the DOMUserData associated to the given key on this node, or null
     *         if there was none.
     */
    public Object getUserData(String key) {
        throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
    }

    public Node item(int index) {
        if (index < 0 || index >= nChildren) {
            return null;
        }

        Node n;
        for (n = getFirstChild(); index > 0; index--) {
            n = n.getNextSibling();
        }

        return n;
    }

    public int getLength() {
        return nChildren;
    }

    /**
     * Gets the user object associated with this node.
     * 
     * @return the user object associated with this node.
     */
    public Object getUserObject() {
        return userObject;
    }

    /**
     * Sets the user object associated with this node.
     * 
     * @param userObject
     *            the new user object associated with this node.
     */
    public void setUserObject(Object userObject) {
        this.userObject = userObject;
    }

    /**
     * The Class IIOMetadataAttr.
     */
    private class IIOMetadataAttr extends IIOMetadataNode implements Attr {

        /**
         * The owner element.
         */
        private Element ownerElement;

        /**
         * Instantiates a new iIO metadata attr.
         * 
         * @param name
         *            the name.
         * @param value
         *            the value.
         * @param owner
         *            the owner.
         */
        public IIOMetadataAttr(String name, String value, Element owner) {
            super(name, value);
            this.ownerElement = owner;
        }

        public String getName() {
            return getNodeName();
        }

        public boolean getSpecified() {
            return true;
        }

        public String getValue() {
            return nodeValue;
        }

        public void setValue(String value) throws DOMException {
            nodeValue = value;
        }

        public Element getOwnerElement() {
            return ownerElement;
        }

        /**
         * Sets the owner element.
         * 
         * @param ownerElement
         *            the new owner element.
         */
        public void setOwnerElement(Element ownerElement) {
            this.ownerElement = ownerElement;
        }

        /**
         * @return
         */
        public boolean isId() {
            throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
        }

        @Override
        public short getNodeType() {
            return ATTRIBUTE_NODE;
        }
    }

    /**
     * The Class IIOMetadataNodeList.
     */
    private class IIOMetadataNodeList implements NodeList, NamedNodeMap {

        /**
         * The list.
         */
        private List<IIOMetadataNode> list;

        /**
         * Instantiates a new iIO metadata node list.
         * 
         * @param list
         *            the list.
         */
        IIOMetadataNodeList(List<IIOMetadataNode> list) {
            this.list = list;
        }

        public Node item(int index) {
            try {
                return list.get(index);
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        public int getLength() {
            return list.size();
        }

        public Node getNamedItem(String name) {
            for (IIOMetadataNode node : list) {
                if (name.equals(node.getNodeName())) {
                    return node;
                }
            }
            return null;
        }

        public Node setNamedItem(Node arg) throws DOMException {
            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
                    "This NamedNodeMap is read-only!");
        }

        public Node removeNamedItem(String name) throws DOMException {
            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
                    "This NamedNodeMap is read-only!");
        }

        public Node getNamedItemNS(String namespaceURI, String localName) throws DOMException {
            return getNamedItem(localName);
        }

        public Node setNamedItemNS(Node arg) throws DOMException {
            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
                    "This NamedNodeMap is read-only!");
        }

        public Node removeNamedItemNS(String namespaceURI, String localName) throws DOMException {
            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
                    "This NamedNodeMap is read-only!");
        }
    }
}