abstractelement.java

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

        } else {
            namespace = getNamespaceForPrefix("");
        }

        Element node;

        if (namespace != null) {
            QName qname = factory.createQName(localName, namespace);

            node = factory.createElement(qname);
        } else {
            node = factory.createElement(name);
        }

        addNewNode(node);

        return node;
    }

    public Element addEntity(String name, String text) {
        Entity node = getDocumentFactory().createEntity(name, text);

        addNewNode(node);

        return this;
    }

    public Element addNamespace(String prefix, String uri) {
        Namespace node = getDocumentFactory().createNamespace(prefix, uri);

        addNewNode(node);

        return this;
    }

    public Element addProcessingInstruction(String target, String data) {
        ProcessingInstruction node = getDocumentFactory()
                .createProcessingInstruction(target, data);

        addNewNode(node);

        return this;
    }

    public Element addProcessingInstruction(String target, Map data) {
        ProcessingInstruction node = getDocumentFactory()
                .createProcessingInstruction(target, data);

        addNewNode(node);

        return this;
    }

    public Element addText(String text) {
        Text node = getDocumentFactory().createText(text);

        addNewNode(node);

        return this;
    }

    // polymorphic node methods
    public void add(Node node) {
        switch (node.getNodeType()) {
            case ELEMENT_NODE:
                add((Element) node);

                break;

            case ATTRIBUTE_NODE:
                add((Attribute) node);

                break;

            case TEXT_NODE:
                add((Text) node);

                break;

            case CDATA_SECTION_NODE:
                add((CDATA) node);

                break;

            case ENTITY_REFERENCE_NODE:
                add((Entity) node);

                break;

            case PROCESSING_INSTRUCTION_NODE:
                add((ProcessingInstruction) node);

                break;

            case COMMENT_NODE:
                add((Comment) node);

                break;

            /*
             * XXXX: to do! case DOCUMENT_TYPE_NODE: add((DocumentType) node);
             * break;
             */
            case NAMESPACE_NODE:
                add((Namespace) node);

                break;

            default:
                invalidNodeTypeAddException(node);
        }
    }

    public boolean remove(Node node) {
        switch (node.getNodeType()) {
            case ELEMENT_NODE:
                return remove((Element) node);

            case ATTRIBUTE_NODE:
                return remove((Attribute) node);

            case TEXT_NODE:
                return remove((Text) node);

            case CDATA_SECTION_NODE:
                return remove((CDATA) node);

            case ENTITY_REFERENCE_NODE:
                return remove((Entity) node);

            case PROCESSING_INSTRUCTION_NODE:
                return remove((ProcessingInstruction) node);

            case COMMENT_NODE:
                return remove((Comment) node);

            /*
             * case DOCUMENT_TYPE_NODE: return remove((DocumentType) node);
             */
            case NAMESPACE_NODE:
                return remove((Namespace) node);

            default:
                return false;
        }
    }

    // typesafe versions using node classes
    public void add(CDATA cdata) {
        addNode(cdata);
    }

    public void add(Comment comment) {
        addNode(comment);
    }

    public void add(Element element) {
        addNode(element);
    }

    public void add(Entity entity) {
        addNode(entity);
    }

    public void add(Namespace namespace) {
        addNode(namespace);
    }

    public void add(ProcessingInstruction pi) {
        addNode(pi);
    }

    public void add(Text text) {
        addNode(text);
    }

    public boolean remove(CDATA cdata) {
        return removeNode(cdata);
    }

    public boolean remove(Comment comment) {
        return removeNode(comment);
    }

    public boolean remove(Element element) {
        return removeNode(element);
    }

    public boolean remove(Entity entity) {
        return removeNode(entity);
    }

    public boolean remove(Namespace namespace) {
        return removeNode(namespace);
    }

    public boolean remove(ProcessingInstruction pi) {
        return removeNode(pi);
    }

    public boolean remove(Text text) {
        return removeNode(text);
    }

    // Helper methods
    // -------------------------------------------------------------------------
    public boolean hasMixedContent() {
        List content = contentList();

        if ((content == null) || content.isEmpty() || (content.size() < 2)) {
            return false;
        }

        Class prevClass = null;

        for (Iterator iter = content.iterator(); iter.hasNext();) {
            Object object = iter.next();

            Class newClass = object.getClass();

            if (newClass != prevClass) {
                if (prevClass != null) {
                    return true;
                }

                prevClass = newClass;
            }
        }

        return false;
    }

    public boolean isTextOnly() {
        List content = contentList();

        if ((content == null) || content.isEmpty()) {
            return true;
        }

        for (Iterator iter = content.iterator(); iter.hasNext();) {
            Object object = iter.next();

            if (!(object instanceof CharacterData)
                    && !(object instanceof String)) {
                return false;
            }
        }

        return true;
    }

    public void setText(String text) {
        /* remove all text nodes */
        List allContent = contentList();

        if (allContent != null) {
            Iterator it = allContent.iterator();

            while (it.hasNext()) {
                Node node = (Node) it.next();

                switch (node.getNodeType()) {
                    case CDATA_SECTION_NODE:

                    // case ENTITY_NODE:
                    case ENTITY_REFERENCE_NODE:
                    case TEXT_NODE:
                        it.remove();

                    default:
                        break;
                }
            }
        }

        addText(text);
    }

    public String getStringValue() {
        List list = contentList();

        int size = list.size();

        if (size > 0) {
            if (size == 1) {
                // optimised to avoid StringBuffer creation
                return getContentAsStringValue(list.get(0));
            } else {
                StringBuffer buffer = new StringBuffer();

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

                    String string = getContentAsStringValue(node);

                    if (string.length() > 0) {
                        if (USE_STRINGVALUE_SEPARATOR) {
                            if (buffer.length() > 0) {
                                buffer.append(' ');
                            }
                        }

                        buffer.append(string);
                    }
                }

                return buffer.toString();
            }
        }

        return "";
    }

    /**
     * Puts all <code>Text</code> nodes in the full depth of the sub-tree
     * underneath this <code>Node</code>, including attribute nodes, into a
     * "normal" form where only structure (e.g., elements, comments, processing
     * instructions, CDATA sections, and entity references) separates
     * <code>Text</code> nodes, i.e., there are neither adjacent
     * <code>Text</code> nodes nor empty <code>Text</code> nodes. This can
     * be used to ensure that the DOM view of a document is the same as if it
     * were saved and re-loaded, and is useful when operations (such as XPointer
     * lookups) that depend on a particular document tree structure are to be
     * used.In cases where the document contains <code>CDATASections</code>,
     * the normalize operation alone may not be sufficient, since XPointers do
     * not differentiate between <code>Text</code> nodes and
     * <code>CDATASection</code> nodes.
     * 
     * @since DOM Level 2
     */
    public void normalize() {
        List content = contentList();

        Text previousText = null;

        int i = 0;

        while (i < content.size()) {
            Node node = (Node) content.get(i);

            if (node instanceof Text) {
                Text text = (Text) node;

                if (previousText != null) {
                    previousText.appendText(text.getText());

                    remove(text);
                } else {
                    String value = text.getText();

                    // only remove empty Text nodes, not whitespace nodes
                    // if ( value == null || value.trim().length() <= 0 ) {
                    if ((value == null) || (value.length() <= 0)) {
                        remove(text);
                    } else {
                        previousText = text;

                        i++;
                    }
                }
            } else {
                if (node instanceof Element) {
                    Element element = (Element) node;

                    element.normalize();
                }

                previousText = null;

                i++;
            }
        }
    }

    public String elementText(String name) {
        Element element = element(name);

        return (element != null) ? element.getText() : null;
    }

    public String elementText(QName qName) {
        Element element = element(qName);

        return (element != null) ? element.getText() : null;
    }

    public String elementTextTrim(String name) {
        Element element = element(name);

        return (element != null) ? element.getTextTrim() : null;
    }

    public String elementTextTrim(QName qName) {
        Element element = element(qName);

        return (element != null) ? element.getTextTrim() : null;
    }

    // add to me content from another element
    // analagous to the addAll(collection) methods in Java 2 collections
    public void appendAttributes(Element element) {
        for (int i = 0, size = element.attributeCount(); i < size; i++) {
            Attribute attribute = element.attribute(i);

            if (attribute.supportsParent()) {
                addAttribute(attribute.getQName(), attribute.getValue());
            } else {
                add(attribute);
            }
        }
    }

    /**
     * <p>
     * This returns a deep clone of this element. The new element is detached
     * from its parent, and getParent() on the clone will return null.
     * </p>
     * 
     * @return the clone of this element
     */

    /*