public DOMElement(String name) 
{
       
        super(name);
}

 public DOMElement(QName qname) 
{
        super(qname);
}

 public DOMElement(QName qname,
    int attributeCount) 
{
        super(qname, attributeCount);
}

 public DOMElement(String name,
    Namespace namespace) 
{
        super(name, namespace);
}

 public Node appendChild(Node newChild) throws DOMException 
{
        checkNewChildNode(newChild);
        return DOMNodeHelper.appendChild(this, newChild);
}

 protected Attribute attribute(Attr attr) 
{
        return attribute(DOCUMENT_FACTORY.createQName(attr.getLocalName(), attr
                .getPrefix(), attr.getNamespaceURI()));
}

 protected Attribute attribute(String namespaceURI,
    String localName) 
{
        List attributes = attributeList();
        int size = attributes.size();
        for (int i = 0; i <  size; i++) {
            Attribute attribute = (Attribute) attributes.get(i);
            if (localName.equals(attribute.getName())
                    && (((namespaceURI == null || namespaceURI.length() == 0)
                          && ((attribute.getNamespaceURI() == null) 
                              || (attribute.getNamespaceURI().length() == 0)))
                              || ((namespaceURI != null) && namespaceURI
                                      .equals(attribute.getNamespaceURI())))) {
                return attribute;
            }
        }
        return null;
}

 public Node cloneNode(boolean deep) 
{
        return DOMNodeHelper.cloneNode(this, deep);
}

 protected Attribute createAttribute(Attr newAttr) 
{
        QName qname = null;
        String name = newAttr.getLocalName();
        if (name != null) {
            String prefix = newAttr.getPrefix();
            String uri = newAttr.getNamespaceURI();
            qname = getDocumentFactory().createQName(name, prefix, uri);
        } else {
            name = newAttr.getName();
            qname = getDocumentFactory().createQName(name);
        }
        return new DOMAttribute(qname, newAttr.getValue());
}

 public String getAttribute(String name) 
{
        String answer = attributeValue(name);
        return (answer != null) ? answer : "";
}

 public String getAttributeNS(String namespaceURI,
    String localName) 
{
        Attribute attribute = attribute(namespaceURI, localName);
        if (attribute != null) {
            String answer = attribute.getValue();
            if (answer != null) {
                return answer;
            }
        }
        return "";
}

 public Attr getAttributeNode(String name) 
{
        return DOMNodeHelper.asDOMAttr(attribute(name));
}

 public Attr getAttributeNodeNS(String namespaceURI,
    String localName) 
{
        Attribute attribute = attribute(namespaceURI, localName);
        if (attribute != null) {
            DOMNodeHelper.asDOMAttr(attribute);
        }
        return null;
}

 public NamedNodeMap getAttributes() 
{
        return new DOMAttributeNodeMap(this);
}

 public NodeList getChildNodes() 
{
        return DOMNodeHelper.createNodeList(content());
}

 protected DocumentFactory getDocumentFactory() 
{
        DocumentFactory factory = getQName().getDocumentFactory();
        return (factory != null) ? factory : DOCUMENT_FACTORY;
}

 public NodeList getElementsByTagName(String name) 
{
        ArrayList list = new ArrayList();
        DOMNodeHelper.appendElementsByTagName(list, this, name);
        return DOMNodeHelper.createNodeList(list);
}

 public NodeList getElementsByTagNameNS(String namespace,
    String lName) 
{
        ArrayList list = new ArrayList();
        DOMNodeHelper.appendElementsByTagNameNS(list, this, namespace, lName);
        return DOMNodeHelper.createNodeList(list);
}

 public Node getFirstChild() 
{
        return DOMNodeHelper.asDOMNode(node(0));
}

 public Node getLastChild() 
{
        return DOMNodeHelper.asDOMNode(node(nodeCount() - 1));
}

 public String getLocalName() 
{
        return getQName().getName();
}

 public String getNamespaceURI() 
{
        return getQName().getNamespaceURI();
}

 public Node getNextSibling() 
{
        return DOMNodeHelper.getNextSibling(this);
}

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

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

 public Document getOwnerDocument() 
{
        return DOMNodeHelper.getOwnerDocument(this);
}

 public Node getParentNode() 
{
        return DOMNodeHelper.getParentNode(this);
}

 public String getPrefix() 
{
        return getQName().getNamespacePrefix();
}

 public Node getPreviousSibling() 
{
        return DOMNodeHelper.getPreviousSibling(this);
}

 protected QName getQName(String namespace,
    String qualifiedName) 
{
        int index = qualifiedName.indexOf(':");
        String prefix = "";
        String localName = qualifiedName;
        if (index  >= 0) {
            prefix = qualifiedName.substring(0, index);
            localName = qualifiedName.substring(index + 1);
        }
        return getDocumentFactory().createQName(localName, prefix, namespace);
}

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

 public boolean hasAttribute(String name) 
{
        return attribute(name) != null;
}

 public boolean hasAttributeNS(String namespaceURI,
    String localName) 
{
        return attribute(namespaceURI, localName) != null;
}

 public boolean hasAttributes() 
{
        return DOMNodeHelper.hasAttributes(this);
}

 public boolean hasChildNodes() 
{
        return nodeCount()  > 0;
}

 public Node insertBefore(Node newChild,
    Node refChild) throws DOMException 
{
        checkNewChildNode(newChild);
        return DOMNodeHelper.insertBefore(this, newChild, refChild);
}

 public boolean isSupported(String feature,
    String version) 
{
        return DOMNodeHelper.isSupported(this, feature, version);
}

 public  void removeAttribute(String name) throws DOMException 
{
        Attribute attribute = attribute(name);
        if (attribute != null) {
            remove(attribute);
        }
}

 public  void removeAttributeNS(String namespaceURI,
    String localName) throws DOMException 
{
        Attribute attribute = attribute(namespaceURI, localName);
        if (attribute != null) {
            remove(attribute);
        }
}

 public Attr removeAttributeNode(Attr oldAttr) throws DOMException 
{
        Attribute attribute = attribute(oldAttr);
        if (attribute != null) {
            attribute.detach();
            return DOMNodeHelper.asDOMAttr(attribute);
        } else {
            throw new DOMException(DOMException.NOT_FOUND_ERR,
                    "No such attribute");
        }
}

 public Node removeChild(Node oldChild) throws DOMException 
{
        return DOMNodeHelper.removeChild(this, oldChild);
}

 public Node replaceChild(Node newChild,
    Node oldChild) throws DOMException 
{
        checkNewChildNode(newChild);
        return DOMNodeHelper.replaceChild(this, newChild, oldChild);
}

 public  void setAttribute(String name,
    String value) throws DOMException 
{
        addAttribute(name, value);
}

 public  void setAttributeNS(String namespaceURI,
    String qualifiedName,
    String value) throws DOMException 
{
        Attribute attribute = attribute(namespaceURI, qualifiedName);
        if (attribute != null) {
            attribute.setValue(value);
        } else {
            QName qname = getQName(namespaceURI, qualifiedName);
            addAttribute(qname, value);
        }
}

 public Attr setAttributeNode(Attr newAttr) throws DOMException 
{
        if (this.isReadOnly()) {
            throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
                    "No modification allowed");
        }
        Attribute attribute = attribute(newAttr);
        if (attribute != newAttr) {
            if (newAttr.getOwnerElement() != null) {
                throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR,
                        "Attribute is already in use");
            }
            Attribute newAttribute = createAttribute(newAttr);
            if (attribute != null) {
                attribute.detach();
            }
            add(newAttribute);
        }
        return DOMNodeHelper.asDOMAttr(attribute);
}

 public Attr setAttributeNodeNS(Attr newAttr) throws DOMException 
{
        Attribute attribute = attribute(newAttr.getNamespaceURI(), newAttr
                .getLocalName());
        if (attribute != null) {
            attribute.setValue(newAttr.getValue());
        } else {
            attribute = createAttribute(newAttr);
            add(attribute);
        }
        return DOMNodeHelper.asDOMAttr(attribute);
}

 public  void setNodeValue(String nodeValue) throws DOMException 
{

}

 public  void setPrefix(String prefix) throws DOMException 
{
        DOMNodeHelper.setPrefix(this, prefix);
}

 public boolean supports(String feature,
    String version) 
{
        return DOMNodeHelper.supports(this, feature, version);
}