abstractelement.java

解决如何把XML应用到JAVA里问题

/*
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 *
 * This software is open source.
 * See the bottom of this file for the licence.
 */

package org.dom4j.tree;

import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.CharacterData;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.Entity;
import org.dom4j.IllegalAddException;
import org.dom4j.Namespace;
import org.dom4j.Node;
import org.dom4j.ProcessingInstruction;
import org.dom4j.QName;
import org.dom4j.Text;
import org.dom4j.Visitor;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import org.xml.sax.Attributes;

/**
 * <p>
 * <code>AbstractElement</code> is an abstract base class for tree
 * implementors to use for implementation inheritence.
 * </p>
 * 
 * @author <a href="mailto:[e-mail]">James Strachan </a>
 * @version $Revision: 1.80 $
 */
public abstract class AbstractElement extends AbstractBranch implements
        org.dom4j.Element {
    /** The <code>DocumentFactory</code> instance used by default */
    private static final DocumentFactory DOCUMENT_FACTORY = DocumentFactory
            .getInstance();

    protected static final List EMPTY_LIST = Collections.EMPTY_LIST;

    protected static final Iterator EMPTY_ITERATOR = EMPTY_LIST.iterator();

    protected static final boolean VERBOSE_TOSTRING = false;

    protected static final boolean USE_STRINGVALUE_SEPARATOR = false;

    public AbstractElement() {
    }

    public short getNodeType() {
        return ELEMENT_NODE;
    }

    public boolean isRootElement() {
        Document document = getDocument();

        if (document != null) {
            Element root = document.getRootElement();

            if (root == this) {
                return true;
            }
        }

        return false;
    }

    public void setName(String name) {
        setQName(getDocumentFactory().createQName(name));
    }

    public void setNamespace(Namespace namespace) {
        setQName(getDocumentFactory().createQName(getName(), namespace));
    }

    /**
     * Returns the XPath expression to match this Elements name which is
     * getQualifiedName() if there is a namespace prefix defined or if no
     * namespace is present then it is getName() or if a namespace is defined
     * with no prefix then the expression is [name()='X'] where X = getName().
     * 
     * @return DOCUMENT ME!
     */
    public String getXPathNameStep() {
        String uri = getNamespaceURI();

        if ((uri == null) || (uri.length() == 0)) {
            return getName();
        }

        String prefix = getNamespacePrefix();

        if ((prefix == null) || (prefix.length() == 0)) {
            return "*[name()='" + getName() + "']";
        }

        return getQualifiedName();
    }

    public String getPath(Element context) {
        if (this == context) {
            return ".";
        }

        Element parent = getParent();

        if (parent == null) {
            return "/" + getXPathNameStep();
        } else if (parent == context) {
            return getXPathNameStep();
        }

        return parent.getPath(context) + "/" + getXPathNameStep();
    }

    public String getUniquePath(Element context) {
        Element parent = getParent();

        if (parent == null) {
            return "/" + getXPathNameStep();
        }

        StringBuffer buffer = new StringBuffer();

        if (parent != context) {
            buffer.append(parent.getUniquePath(context));

            buffer.append("/");
        }

        buffer.append(getXPathNameStep());

        List mySiblings = parent.elements(getQName());

        if (mySiblings.size() > 1) {
            int idx = mySiblings.indexOf(this);

            if (idx >= 0) {
                buffer.append("[");

                buffer.append(Integer.toString(++idx));

                buffer.append("]");
            }
        }

        return buffer.toString();
    }

    public String asXML() {
        try {
            StringWriter out = new StringWriter();
            XMLWriter writer = new XMLWriter(out, new OutputFormat());

            writer.write(this);
            writer.flush();

            return out.toString();
        } catch (IOException e) {
            throw new RuntimeException("IOException while generating "
                    + "textual representation: " + e.getMessage());
        }
    }

    public void write(Writer out) throws IOException {
        XMLWriter writer = new XMLWriter(out, new OutputFormat());
        writer.write(this);
    }

    /**
     * <p>
     * <code>accept</code> method is the <code>Visitor Pattern</code>
     * method.
     * </p>
     * 
     * @param visitor
     *            <code>Visitor</code> is the visitor.
     */
    public void accept(Visitor visitor) {
        visitor.visit(this);

        // visit attributes
        for (int i = 0, size = attributeCount(); i < size; i++) {
            Attribute attribute = attribute(i);

            visitor.visit(attribute);
        }

        // visit content
        for (int i = 0, size = nodeCount(); i < size; i++) {
            Node node = node(i);

            node.accept(visitor);
        }
    }

    public String toString() {
        String uri = getNamespaceURI();

        if ((uri != null) && (uri.length() > 0)) {
            if (VERBOSE_TOSTRING) {
                return super.toString() + " [Element: <" + getQualifiedName()
                        + " uri: " + uri + " attributes: " + attributeList()
                        + " content: " + contentList() + " />]";
            } else {
                return super.toString() + " [Element: <" + getQualifiedName()
                        + " uri: " + uri + " attributes: " + attributeList()
                        + "/>]";
            }
        } else {
            if (VERBOSE_TOSTRING) {
                return super.toString() + " [Element: <" + getQualifiedName()
                        + " attributes: " + attributeList() + " content: "
                        + contentList() + " />]";
            } else {
                return super.toString() + " [Element: <" + getQualifiedName()
                        + " attributes: " + attributeList() + "/>]";
            }
        }
    }

    // QName methods
    // -------------------------------------------------------------------------
    public Namespace getNamespace() {
        return getQName().getNamespace();
    }

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

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

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

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

    public Object getData() {
        return getText();
    }

    public void setData(Object data) {
        // ignore this method
    }

    // Node methods
    // -------------------------------------------------------------------------
    public Node node(int index) {
        if (index >= 0) {
            List list = contentList();

            if (index >= list.size()) {
                return null;
            }

            Object node = list.get(index);

            if (node != null) {
                if (node instanceof Node) {
                    return (Node) node;
                } else {
                    return getDocumentFactory().createText(node.toString());
                }
            }
        }

        return null;
    }

    public int indexOf(Node node) {
        return contentList().indexOf(node);
    }

    public int nodeCount() {
        return contentList().size();
    }

    public Iterator nodeIterator() {
        return contentList().iterator();
    }

    // Element methods
    // -------------------------------------------------------------------------
    public Element element(String name) {
        List list = contentList();

        int size = list.size();

        for (int i = 0; i < size; i++) {
            Object object = list.get(i);

            if (object instanceof Element) {
                Element element = (Element) object;

                if (name.equals(element.getName())) {
                    return element;
                }
            }
        }

        return null;
    }

    public Element element(QName qName) {
        List list = contentList();

        int size = list.size();

        for (int i = 0; i < size; i++) {
            Object object = list.get(i);

            if (object instanceof Element) {
                Element element = (Element) object;

                if (qName.equals(element.getQName())) {
                    return element;
                }
            }
        }

        return null;
    }

    public Element element(String name, Namespace namespace) {
        return element(getDocumentFactory().createQName(name, namespace));
    }

    public List elements() {
        List list = contentList();

        BackedList answer = createResultList();

        int size = list.size();

        for (int i = 0; i < size; i++) {
            Object object = list.get(i);

            if (object instanceof Element) {
                answer.addLocal(object);
            }
        }

        return answer;
    }

    public List elements(String name) {
        List list = contentList();

        BackedList answer = createResultList();

        int size = list.size();

        for (int i = 0; i < size; i++) {
            Object object = list.get(i);

            if (object instanceof Element) {
                Element element = (Element) object;

                if (name.equals(element.getName())) {
                    answer.addLocal(element);
                }
            }
        }

        return answer;
    }

    public List elements(QName qName) {
        List list = contentList();

        BackedList answer = createResultList();

        int size = list.size();

        for (int i = 0; i < size; i++) {
            Object object = list.get(i);

            if (object instanceof Element) {
                Element element = (Element) object;

                if (qName.equals(element.getQName())) {
                    answer.addLocal(element);
                }
            }
        }

        return answer;
    }

    public List elements(String name, Namespace namespace) {
        return elements(getDocumentFactory().createQName(name, namespace));
    }

    public Iterator elementIterator() {
        List list = elements();

        return list.iterator();
    }

    public Iterator elementIterator(String name) {
        List list = elements(name);