/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 *

 *      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 com.sun.org.apache.xerces.internal.dom;

import org.w3c.dom.Attr;

import org.w3c.dom.DOMException;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Text;

import org.w3c.dom.TypeInfo;

import com.sun.org.apache.xerces.internal.util.URI;

/**

 * <P>

 * Elements may have Attributes associated with them; the API for this is

 * defined in Node, but the function is implemented here. In general, XML

 * applications should retrive Attributes as Nodes, since they may contain

 * <P>

 * ElementImpl does not support Namespaces. ElementNSImpl, which inherits from

 * it, does.

 * @see ElementNSImpl

 *

 * @xerces.internal

 *

 * @author Joe Kesselman, IBM

 * @author Andy Clark, IBM

 * @author Ralf Pfeiffer, IBM

 */

public class ElementImpl

    //

    // Constants

    //

    static final long serialVersionUID = 3717253516652722278L;

    //

    // Data

    //

    protected String name;

    protected AttributeMap attributes;

    //

    // Constructors

    //

    public ElementImpl(CoreDocumentImpl ownerDoc, String name) {

        super(ownerDoc);

        this.name = name;

        needsSyncData(true);    // synchronizeData will initialize attributes

    }

    // for ElementNSImpl

    // Support for DOM Level 3 renameNode method.

    // Note: This only deals with part of the pb. CoreDocumentImpl

    // does all the work.

    void rename(String name) {

        if (needsSyncData()) {

            synchronizeData();

        }

        reconcileDefaultAttributes();

    }

    //

    // Node methods

    //

    /**

     */

    public short getNodeType() {

        return Node.ELEMENT_NODE;

    }

    /**

     */

    public String getNodeName() {

        if (needsSyncData()) {

            synchronizeData();

        }

        return name;

    }

    /**

     * Retrieve all the Attributes as a set. Note that this API is inherited

     * from Node rather than specified on Element; in fact only Elements will

     * ever have Attributes, but they want to allow folks to "blindly" operate

     * on the tree as a set of Nodes.

     */

    public NamedNodeMap getAttributes() {

        if (needsSyncData()) {

            synchronizeData();

        }

        if (attributes == null) {

            attributes = new AttributeMap(this, null);

        }

        return attributes;

    } // getAttributes():NamedNodeMap

    /**

     *

     * @see org.w3c.dom.Node#cloneNode(boolean)

     */

    public Node cloneNode(boolean deep) {

        ElementImpl newnode = (ElementImpl) super.cloneNode(deep);

        // Replicate NamedNodeMap rather than sharing it.

        if (attributes != null) {

            newnode.attributes = (AttributeMap) attributes.cloneMap(newnode);

        }

        return newnode;

    } // cloneNode(boolean):Node

     */

    public String getBaseURI() {

        if (needsSyncData()) {

            synchronizeData();

        }

        // Absolute base URI is computed according to

        // XML Base (http://www.w3.org/TR/xmlbase/#granularity)

        // 1. The base URI specified by an xml:base attribute on the element,

        // if one exists

        if (attributes != null) {

            if (attrNode != null) {

                    try {

                        // Make any parentURI into a URI object to use with the URI(URI, String) constructor

                        String parentBaseURI = (this.ownerNode != null) ? this.ownerNode.getBaseURI() : null;

                                // This should never happen: parent should have checked the URI and returned null if invalid.

                                return null;

                            }

                        }

                        return null;

                    }

                }

            }

        }

        // 2.the base URI of the element's parent element within the

        // document or external entity, if one exists

    } //getBaseURI

    /**

     */

        super.setOwnerDocument(doc);

        if (attributes != null) {

            attributes.setOwnerDocument(doc);

        }

    }

    //

    // Element methods

    //

    /**

     * <p>

     */

    public String getAttribute(String name) {

        if (needsSyncData()) {

            synchronizeData();

        }

        if (attributes == null) {

            return "";

        }

        return (attr == null) ? "" : attr.getValue();

    } // getAttribute(String):String

    /**

     * <p>

     * If no matching attribute is available, returns null.

     */

    public Attr getAttributeNode(String name) {

        if (needsSyncData()) {

            synchronizeData();

        }

        if (attributes == null) {

            return null;

        }

    } // getAttributeNode(String):Attr

    /**

     * <p>

     *

     *

     * @see DeepNodeListImpl

     */

    public NodeList getElementsByTagName(String tagname) {

    }

    /**

     * <p>

     */

    public String getTagName() {

        if (needsSyncData()) {

            synchronizeData();

        }

        return name;

    }

    /**

     * In "normal form" (as read from a source file), there will never be two

     * Text children in succession. But DOM users may create successive Text

     * nodes in the course of manipulating the document. Normalize walks the

     * sub-tree and merges adjacent Texts, as if the DOM had been written out

     * and read back in again. This simplifies implementation of higher-level

     * functions that may want to assume that the document is in standard form.

     * <p>

     * To normalize a Document, normalize its top-level Element child.

     * <p>

     */

    public void normalize() {

        // No need to normalize if already normalized.

        if (isNormalized()) {

            return;

        }

        if (needsSyncChildren()) {

            synchronizeChildren();

        }

        ChildNode kid, next;

        for (kid = firstChild; kid != null; kid = next) {

            next = kid.nextSibling;

            // If kid is a text node, we need to check for one of two

            // conditions:

            //   1) There is an adjacent text node

            //   2) There is no adjacent text node, but kid is

            //      an empty text node.

                // If an adjacent text node, merge it with kid

                    next = kid; // Don't advance; there might be another.

                    // If kid is empty, remove it

                    }

                }

            else if (kid.getNodeType() == Node.ELEMENT_NODE) {

                kid.normalize();

            }

        }

        // We must also normalize all of the attributes

                Node attr = attributes.item(i);

                attr.normalize();

            }

        }

        // changed() will have occurred when the removeChild() was done,

        // so does not have to be reissued.

        isNormalized(true);

    } // normalize()

    /**

     * <P>

     * The default logic is actually implemented in NamedNodeMapImpl.

     * <P>

     *

     * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if the node is

     * readonly.

     */

    public void removeAttribute(String name) {

        if (ownerDocument.errorChecking && isReadOnly()) {

            String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null);

            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg);

        }

        if (needsSyncData()) {

            synchronizeData();

        }

        if (attributes == null) {

            return;

        }

        attributes.safeRemoveNamedItem(name);

    } // removeAttribute(String)

    /**

     * <p>

     *

     * @return the Attribute object that was removed.

     * @throws DOMException(NOT_FOUND_ERR) if oldattr is not an attribute of

     * this Element.

     * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if the node is

     * readonly.

     */

    public Attr removeAttributeNode(Attr oldAttr)

        if (ownerDocument.errorChecking && isReadOnly()) {

            String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null);

            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg);

        }

        if (needsSyncData()) {

            synchronizeData();

        }

        if (attributes == null) {

            String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null);

            throw new DOMException(DOMException.NOT_FOUND_ERR, msg);

        }

        return (Attr) attributes.removeItem(oldAttr, true);

    } // removeAttributeNode(Attr):Attr

    /**

     *

     *

     *

     * @throws DOMException(INVALID_NAME_ERR) if the name is not acceptable.

     * (Attribute factory will do that test for us.)

     *

     * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if the node is

     * readonly.

     */