/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.tax.dom;

import org.w3c.dom.*;
import org.netbeans.tax.*;

/**
 *
 * @author  Petr Kuzel
 */
class ElementImpl extends NodeImpl implements  Element {
    
    private final TreeElement peer;
    
    /** Creates a new instance of ElementImpl */
    public ElementImpl(TreeElement peer) {
        this.peer = peer;
    }
        
    
    /** Retrieves an attribute value by name.
     * @param name The name of the attribute to retrieve.
     * @return The Attr value as a string, or the empty string
     *   if that attribute does not have a specified or default value.
     *
     */
    public String getAttribute(String name) {
        return peer.getAttribute(name).getValue();
    }
    
    /** Retrieves an attribute value by local name and namespace URI.
     * 
Documents which do not support the "XML" feature will permit only
     * the DOM Level 1 calls for creating/setting elements and attributes.
     * Hence, if you specify a non-null namespace URI, these DOMs will never
     * find a matching node.
     * @param namespaceURI The namespace URI of the attribute to retrieve.
     * @param localName The local name of the attribute to retrieve.
     * @return The Attr value as a string, or the empty string
     *   if that attribute does not have a specified or default value.
     * @since DOM Level 2
     *
     */
    public String getAttributeNS(String namespaceURI, String localName) {
        throw new UOException();
    }
    
    /** Retrieves an attribute node by name.
     * 
To retrieve an attribute node by qualified name and namespace URI,
     * use the getAttributeNodeNS method.
     * @param name The name (nodeName) of the attribute to
     *   retrieve.
     * @return The Attr node with the specified name (
     *   nodeName) or null if there is no such
     *   attribute.
     *
     */
    public Attr getAttributeNode(String name) {
        return Wrapper.wrap(peer.getAttribute(name));
    }
    
    /** Retrieves an Attr node by local name and namespace URI.
     * 
Documents which do not support the "XML" feature will permit only
     * the DOM Level 1 calls for creating/setting elements and attributes.
     * Hence, if you specify a non-null namespace URI, these DOMs will never
     * find a matching node.
     * @param namespaceURI The namespace URI of the attribute to retrieve.
     * @param localName The local name of the attribute to retrieve.
     * @return The Attr node with the specified attribute local
     *   name and namespace URI or null if there is no such
     *   attribute.
     * @since DOM Level 2
     *
     */
    public Attr getAttributeNodeNS(String namespaceURI, String localName) {
        throw new UOException();
    }
    
    /** A NamedNodeMap containing the attributes of this node (if
     * it is an Element) or null otherwise.
     *
     */
    public NamedNodeMap getAttributes() {
        return Wrapper.wrap(peer.getAttributes());
    }
    
    /** A NodeList that contains all children of this node. If
     * there are no children, this is a NodeList containing no
     * nodes.
     *
     */
    public NodeList getChildNodes() {
        return Wrapper.wrap(peer.getChildNodes());
    }
    
    /** Returns a NodeList of all descendant Elements
     * with a given tag name, in the order in which they are encountered in
     * a preorder traversal of this Element tree.
     * @param name The name of the tag to match on. The special value "*"
     *   matches all tags.
     * @return A list of matching Element nodes.
     *
     */
    public NodeList getElementsByTagName(String name) {
        throw new UOException();
    }
    
    /** Returns a NodeList of all the descendant
     * Elements with a given local name and namespace URI in
     * the order in which they are encountered in a preorder traversal of
     * this Element tree.
     * 
Documents which do not support the "XML" feature will permit only
     * the DOM Level 1 calls for creating/setting elements and attributes.
     * Hence, if you specify a non-null namespace URI, these DOMs will never
     * find a matching node.
     * @param namespaceURI The namespace URI of the elements to match on. The
     *   special value "*" matches all namespaces.
     * @param localName The local name of the elements to match on. The
     *   special value "*" matches all local names.
     * @return A new NodeList object containing all the matched
     *   Elements.
     * @since DOM Level 2
     *
     */
    public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
        throw new UOException();
    }
    
    /** The first child of this node. If there is no such node, this returns
     * null.
     *
     */
    public Node getFirstChild() {
        return Wrapper.wrap(peer.getFirstChild());
    }
    
    /** The last child of this node. If there is no such node, this returns
     * null.
     *
     */
    public Node getLastChild() {
        return Wrapper.wrap(peer.getLastChild());        
    }
    
    
    /** The node immediately following this node. If there is no such node,
     * this returns null.
     *
     */
    public Node getNextSibling() {
        return Children.getNextSibling(peer);
    }
    
    /** The name of this node, depending on its type; see the table above.
     *
     */
    public String getNodeName() {
        return getTagName();
    }
    
    /** A code representing the type of the underlying object, as defined above.
     *
     */
    public short getNodeType() {
        return Node.ELEMENT_NODE;
    }
    
    /** 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.
     * @exception DOMException
     *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
     * @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 {
        return null;
    }
    
    
    /** 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() {
        return Wrapper.wrap(peer.getParentNode());
    }    
    
    /** The node immediately preceding this node. If there is no such node,
     * this returns null.
     *
     */
    public Node getPreviousSibling() {
        return Children.getPreviousSibling(peer);
    }
    
    /** The name of the element. For example, in:
     * 
 <elementExample
     * id="demo"> ... </elementExample> , 
     *  tagName has
     * the value "elementExample". Note that this is
     * case-preserving in XML, as are all of the operations of the DOM. The
     * HTML DOM returns the tagName of an HTML element in the
     * canonical uppercase form, regardless of the case in the source HTML
     * document.
     *
     */
    public String getTagName() {
        return peer.getQName();
    }
    
    /** Returns true when an attribute with a given name is
     * specified on this element or has a default value, false
     * otherwise.
     * @param name The name of the attribute to look for.
     * @return true if an attribute with the given name is
     *   specified on this element or has a default value, false
     *    otherwise.
     * @since DOM Level 2
     *
     */
    public boolean hasAttribute(String name) {
        throw new UOException();
    }
    
    /** Returns true when an attribute with a given local name and
     * namespace URI is specified on this element or has a default value,
     * false otherwise.
     * 
Documents which do not support the "XML" feature will permit only
     * the DOM Level 1 calls for creating/setting elements and attributes.
     * Hence, if you specify a non-null namespace URI, these DOMs will never
     * find a matching node.
     * @param namespaceURI The namespace URI of the attribute to look for.
     * @param localName The local name of the attribute to look for.
     * @return true if an attribute with the given local name
     *   and namespace URI is specified or has a default value on this
     *   element, false otherwise.
     * @since DOM Level 2
     *
     */
    public boolean hasAttributeNS(String namespaceURI, String localName) {
        throw new UOException();
    }
    
    /** Returns whether this node (if it is an element) has any attributes.
     * @return true if this node has any attributes,
     *   false otherwise.
     * @since DOM Level 2
     *
     */
    public boolean hasAttributes() {
        return peer.hasAttributes();
    }
    
    /** Returns whether this node has any children.
     * @return true if this node has any children,
     *   false otherwise.
     *
     */
    public boolean hasChildNodes() {
        return peer.hasChildNodes();
    }
        
    /** Removes an attribute by name. If the removed attribute is known to have
     * a default value, an attribute immediately appears containing the
     * default value as well as the corresponding namespace URI, local name,
     * and prefix when applicable.
     * 
To remove an attribute by local name and namespace URI, use the
     * removeAttributeNS method.
     * @param name The name of the attribute to remove.
     * @exception DOMException
     *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *
     */
    public void removeAttribute(String name) throws DOMException {
        throw new ROException();
    }
    
    /** Removes an attribute by local name and namespace URI. If the removed
     * attribute has a default value it is immediately replaced. The
     * replacing attribute has the same namespace URI and local name, as
     * well as the original prefix.
     * 
Documents which do not support the "XML" feature will permit only
     * the DOM Level 1 calls for creating/setting elements and attributes.
     * Hence, if you specify a non-null namespace URI, these DOMs will never
     * find a matching node.
     * @param namespaceURI The namespace URI of the attribute to remove.
     * @param localName The local name of the attribute to remove.
     * @exception DOMException
     *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     * @since DOM Level 2
     *
     */
    public void removeAttributeNS(String namespaceURI, String localName) throws DOMException {
        throw new ROException();
    }
    
    /** Removes the specified attribute node. If the removed Attr
     * has a default value it is immediately replaced. The replacing
     * attribute has the same namespace URI and local name, as well as the
     * original prefix, when applicable.
     * @param oldAttr The Attr node to remove from the attribute
     *   list.
     * @return The Attr node that was removed.
     * @exception DOMException
     *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *   
NOT_FOUND_ERR: Raised if oldAttr is not an attribute
     *   of the element.
     *
     */
    public Attr removeAttributeNode(Attr oldAttr) throws DOMException {
        throw new ROException();
    }
    
    
    /** 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 as 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 subtree, and use setAttributeNode to assign
     * it as the value of an attribute.
     * 
To set an attribute with a qualified name and namespace URI, use
     * the setAttributeNS method.
     * @param name The name of the attribute to create or alter.
     * @param value Value to set in string form.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
     *   illegal character.
     *   
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *
     */
    public void setAttribute(String name, String value) throws DOMException {
        throw new ROException();
    }
    
    /** Adds a new attribute. If an attribute with the same local name and
     * namespace URI is already present on the element, its prefix is
     * changed to be the prefix part of the qualifiedName, and
     * its value is changed to be 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 as 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 subtree,
     * and use setAttributeNodeNS or
     * setAttributeNode to assign it as the value of an
     * attribute.
     * @param namespaceURI The namespace URI of the attribute to create or
     *   alter.
     * @param qualifiedName The qualified name of the attribute to create or
     *   alter.
     * @param value The value to set in string form.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified qualified name
     *   contains an illegal character, per the XML 1.0 specification .
     *   
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *   
NAMESPACE_ERR: Raised if the qualifiedName is
     *   malformed per the Namespaces in XML specification, if the
     *   qualifiedName has a prefix and the
     *   namespaceURI is null, if the
     *   qualifiedName has a prefix that is "xml" and the
     *   namespaceURI is different from "
     *   http://www.w3.org/XML/1998/namespace", or if the
     *   qualifiedName, or its prefix, is "xmlns" and the
     *   namespaceURI is different from "
     *   http://www.w3.org/2000/xmlns/".
     *   
NOT_SUPPORTED_ERR: Always thrown if the current document does not
     *   support the "XML" feature, since namespaces were
     *   defined by XML.
     * @since DOM Level 2
     *
     */
    public void setAttributeNS(String namespaceURI, String qualifiedName, String value) throws DOMException {
        throw new ROException();
    }
    
    /** Adds a new attribute node. If an attribute with that name (
     * nodeName) is already present in the element, it is
     * replaced by the new one.
     * 
To add a new attribute node with a qualified name and namespace
     * URI, use the setAttributeNodeNS method.
     * @param newAttr The Attr node to add to the attribute list.
     * @return If the newAttr attribute replaces an existing
     *   attribute, the replaced Attr node is returned,
     *   otherwise null is returned.
     * @exception DOMException
     *   WRONG_DOCUMENT_ERR: Raised if newAttr was created from a
     *   different document than the one that created the element.
     *   
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *   
INUSE_ATTRIBUTE_ERR: Raised if newAttr is already an
     *   attribute of another Element object. The DOM user must
     *   explicitly clone Attr nodes to re-use them in other
     *   elements.
     *
     */
    public Attr setAttributeNode(Attr newAttr) throws DOMException {
        throw new ROException();
    }
    
    /** Adds a new attribute. If an attribute with that local name and that
     * namespace URI is already present in the element, it is replaced by
     * the new one.
     * @param newAttr The Attr node to add to the attribute list.
     * @return If the newAttr attribute replaces an existing
     *   attribute with the same local name and namespace URI, the replaced
     *   Attr node is returned, otherwise null is
     *   returned.
     * @exception DOMException
     *   WRONG_DOCUMENT_ERR: Raised if newAttr was created from a
     *   different document than the one that created the element.
     *   
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
     *   
INUSE_ATTRIBUTE_ERR: Raised if newAttr is already an
     *   attribute of another Element object. The DOM user must
     *   explicitly clone Attr nodes to re-use them in other
     *   elements.
     *   
NOT_SUPPORTED_ERR: Always thrown if the current document does not
     *   support the "XML" feature, since namespaces were
     *   defined by XML.
     * @since DOM Level 2
     *
     */
    public Attr setAttributeNodeNS(Attr newAttr) throws DOMException {
        throw new ROException();
    }
    
}