domxmlelement.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

/*
 * $Id: DOMXMLElement.java,v 1.3 2004/02/16 18:31:22 jice Exp $
 *
 * Copyright (c) 2001 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *       Sun Microsystems, Inc. for Project JXTA."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact Project JXTA at http://www.jxta.org.
 *
 * 5. Products derived from this software may not be called "JXTA",
 *    nor may "JXTA" appear in their name, without prior written
 *    permission of Sun.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL SUN MICROSYSTEMS OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Project JXTA.  For more
 * information on Project JXTA, please see
 * <http://www.jxta.org/>.
 *
 * This license is based on the BSD license adopted by the Apache Foundation.
 */

package net.jxta.impl.document;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;

import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

import net.jxta.document.Attribute;
import net.jxta.document.StructuredDocument;
import net.jxta.document.TextElement;

/**
 * This class represent an element of an XML document. XML Documents are formed
 * as a hierarchy of elements. Each element provides a proxy for DOM elements
 * and the text nodes containing values.
 *
 */
public class DOMXMLElement extends XMLElementCommon {
    
    protected DOMXMLDocument root;
    
    /**
     * The DOM node for which this element is a proxy.
     */
    protected Node domNode;
    
    /**
     * Constructor for associating a DOM node with a StructuredDocument Element.
     *
     * @param root the DOM not which is to be associated with this element.
     */
    protected DOMXMLElement(DOMXMLDocument root, Node node) {
        this.root = root;
        domNode = node;
    }
    
    /**
     * Get the name associated with an element.
     *
     * @return A string containing the name of this element.
     */
    public String getName() {
        return getAssocNode().getNodeName();
    }
    
    /**
     * Get the value (if any) associated with an element.
     *
     * @return A string containing the value of this element, if any, otherwise null.
     */
    public String getTextValue() {
        String itsValue = "";
        for( Node eachChild = getAssocNode().getFirstChild(); eachChild != null; eachChild = eachChild.getNextSibling() ) {
            if( Node.TEXT_NODE == eachChild.getNodeType() )
                itsValue += eachChild.getNodeValue();
        }
        
        if ( "".equals( itsValue ) )
            return null;
        else
            return itsValue;
    };
    
    /**
     *  Get the root element of the hierarchy this element belongs to.
     *
     *  @return StructuredDocument root of this element's hierarchy.
     */
    public StructuredDocument getRoot() {
        return root;
    }

    /**
     *  Get the parent of this element. If the element has not been inserted into
     *  the Document then null is returned. If this element is the root of the
     *  Document then it returns itself.
     **/
    public net.jxta.document.Element getParent( ) {
        Node node = getAssocNode();
        
        if( node.getOwnerDocument().equals( node ) )
            return new DOMXMLElement( root, node );
        else
            return new DOMXMLElement( root, node.getParentNode() );
    }
    
    /**
     * Add a child element to this element
     *
     * @param element the element to be added as a child
     */
    public void appendChild(TextElement element) {
        if( !(element instanceof DOMXMLElement) )
            throw new IllegalArgumentException( "element type not supported." );
        
        getAssocNode().appendChild( ((DOMXMLElement) element).getAssocNode() );
    };
    
    /**
     * Returns an enumeration of the immediate children of this element
     *
     * @return An enumeration containing all of the children of this element.
     */
    public Enumeration getChildren() {
        List children = new ArrayList();
        
        for( Node eachChild = getAssocNode().getFirstChild(); eachChild != null; eachChild = eachChild.getNextSibling() ) {
            if( Node.ELEMENT_NODE == eachChild.getNodeType() )
                children.add( new DOMXMLElement( root, eachChild ) );
        }
        
        return Collections.enumeration( children );
    };
    
    /**
     * Returns an enumeration of the immediate children of this element whose
     * name match the specified string.
     *
     * @param name The name which will be matched against.
     * @return An enumeration containing all of the children of this element.
     */
    public Enumeration getChildren( String name ) {
        List children = new ArrayList();
        
        for( Node eachChild = getAssocNode().getFirstChild(); eachChild != null; eachChild = eachChild.getNextSibling() ) {
            if( (Node.ELEMENT_NODE == eachChild.getNodeType()) && (name.equals(eachChild.getNodeName()) ) )
                children.add( new DOMXMLElement( root, eachChild ) );
        }
        
        return Collections.enumeration( children );
    };
    
    /**
     * Tests two elements for equality. For the XML document the definition of
     * equality is:
     *  
     *  <p/><ul>
     *    <li>the item compared against must be an XML Element.</li>
     *
     *    <li>The items must belong to the same document.</li>
     *
     *    <li>The items must have the same name.</li>
     *
     *    <li>The items must have the save textual value.</li>
     * </ul>
     *
     * @param element the element to be compared against.
     * @return true if the elements are equal 
     **/
    public boolean equals( Object element ) {
        if (this == element)
            return true;
        
        if( !(element instanceof DOMXMLElement) )
            return false;
        
        DOMXMLElement xmlElement = (DOMXMLElement) element;
        
        Node me = getAssocNode();
        Node it = xmlElement.getAssocNode();
        
        if( me == it )
            return true;
        
        if( me.getOwnerDocument() != it.getOwnerDocument() )
            return false;
        
        if( !getName().equals( xmlElement.getName() ) )
            return false;
        
        String val1 = getTextValue( );
        String val2 = xmlElement.getTextValue( );
        
        if( (null == val1) && (null == val2) )
            return true;
        
        if( (null == val1) || (null == val2) )
            return false;
        
        return val1.equals( val2 );
    }
    
    /**
     *  Returns the DOM Node associated with this StructuredDocument element.
     *
     *  @return Node    The DOM Node associated with this StructuredDocument element.
     *
     **/
    protected Node getAssocNode() {
        return domNode;
    }

    // Attributable methods

    /**
     *  Adds an attribute with the given name and value. Some implementations
     *  may support only a single value for each distinct name. Others may
     *  support multiple values for each name. If the value being provided
     *  replaces some other value then that value is returned otherwise null
     *  is returned.
     *
     *  @param  name    name of the attribute.
     *  @param  value   value for the attribute.
     *  @return String  containing previous value for this name if the value
     *                  is being replaced otherwise null.
     **/
    public String addAttribute(String name, String value) {
        String oldAttrValue = ((Element)getAssocNode()).getAttribute(name);
        
        ((Element)getAssocNode()).setAttribute(name, value);
        return ( 0 == oldAttrValue.length() ) ? null : oldAttrValue;
    }
    
    /**
     *  Adds an attribute with the given name and value. Some implementations
     *  may support only a single value for each distinct name. Others may
     *  support multiple values for each name. If the value being provided
     *  replaces some other value then that value is returned otherwise null
     *  is returned.
     *
     *  @param  newAttrib    new attribute.
     *  @return String  containing previous value for this name if the value
     *                  is being replaced otherwise null.
     **/
    public String addAttribute(Attribute newAttrib) {
        String oldAttrValue = ((Element)getAssocNode()).getAttribute(newAttrib.getName());
        ((Element)getAssocNode()).setAttribute(newAttrib.getName(), newAttrib.getValue());
        return ( 0 == oldAttrValue.length() ) ? null : oldAttrValue;
    }
    
    /**
     *  Returns an enumerations of the attributes assosicated with this object.
     *  Each element is of type Attribute.
     *
     *  @return Enumeration the attributes associated with this object.
     *
     **/
    public Enumeration getAttributes() {
        NamedNodeMap nmap = ((Element) getAssocNode()).getAttributes();
        if (nmap == null) {
            return Collections.enumeration( Collections.EMPTY_LIST );
        }

        List attrs = new ArrayList();
        for (int i = 0; i < nmap.getLength(); i++) {
            Node domAttr = nmap.item(i);
            Attribute attr = new Attribute(this, 
                                           domAttr.getNodeName(),
                                           domAttr.getNodeValue());
            attrs.add(attr);
        }

        return Collections.enumeration( attrs );
    }
    
    /**
     *  returns a single attribute which matches the name provided. If no such
     *  named attribute exists then null is returned. For impelementations of
     *  this interface which support multiple values for each name only the
     *  first value will be returned. To access all values for a name you must
     *  use getAttributes.
     *
     *  @return Attribute the attributes matching the given name.
     *
     **/
    public Attribute getAttribute(String name) {
        NamedNodeMap nmap = ((Element) getAssocNode()).getAttributes();
        if (nmap == null) {
            return null;
        }

        for (int i = 0; i < nmap.getLength(); i++) {
            Node domAttr = nmap.item(i);
            if (name.equals(domAttr.getNodeName())) {
                Attribute attr = new Attribute(this, 
                                               domAttr.getNodeName(),
                                               domAttr.getNodeValue());
                return attr;
            }
        }

        return null;
     }
}