plaintextelement.java

jxme的一些相关程序,主要是手机上程序开发以及手机和计算机通信的一些程序资料,程序编译需要Ant支持

/*
 * $Id: PlainTextElement.java,v 1.2 2002/03/04 21:42:56 echtcherbina 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.io.Writer;
import java.lang.String;
import java.util.Enumeration;
import java.util.Vector;
//PDA requirements 19.02.2002
//java.util.HashMap -> java.util.Hashtable
//import java.util.HashMap;
import java.util.Hashtable;
//java.util.Iterator -> java.util.Enumeration
//import java.util.Iterator;
import java.util.Enumeration;
//class java.util.Map was not presented in jdk 1.1.8, it was excluded
//import java.util.Map;
//PDA requirements 19.02.2002

import java.io.IOException;

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

import net.jxta.document.Attributable;
import net.jxta.document.Attribute;

/**
 * This class is an implementation of the StructuredDocument interface using
 * simple text
 * @version     $Revision: 1.2 $
 * @since       JXTA 1.0
 */
public class PlainTextElement extends TextElementCommon implements Attributable {
    protected PlainTextDocument doc;

    protected Element parent;

    protected final String name;

    protected final String val;

    private Vector children = new Vector();

    //PDA requirements 19.02.2002
    //java.util.HashMap -> java.util.Hashtable
    //private HashMap attributes = new HashMap();
    private Hashtable attributes = new Hashtable();
    //PDA requirements 19.02.2002

    /** Creates new PlainTextElement */
    protected PlainTextElement( PlainTextDocument doc, String name ) {
        this( doc, name, null );
    }

    /** Creates new PlainTextElement */
    protected PlainTextElement( PlainTextDocument doc, String name, String val ) {
        this.doc = doc;
        this.name = name;
        this.val = val;
    }

    /**
     * Tests two elements for equality.
     *
     * @param element the element to be compared against.
     * @return true if the elements are equal (by whatever definition of
     * equality is appropriate) otherwise false
     */
    public boolean equals( Object element ) {
        if (this == element)
            return true;

        if( !(element instanceof PlainTextElement) )
            return false;

        PlainTextElement textElement = (PlainTextElement) element;

        if( doc != textElement.doc )
            return false;

        if( !getName().equals( textElement.getName() ) )
            return false;

        String val1 = getTextValue( );
        String val2 = textElement.getTextValue( );

        if( (null == val1) && (null == val2) )
            return true;

        if( (null == val1) || (null == val2) )
            return false;

        return val1.equals( val2 );
    }

    /**
     *  Get the root element of the hierarchy this element belongs to.
     *
     *  @return StructuredDocument root of this element's hierarchy.
     *
     *  @since JXTA 1.0
     */
    public StructuredDocument getRoot() {
        return doc;
    }

    /**
     *  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.
     *
     *  @return Element parent of this element
     *
     *  @since JXTA 1.0
     */
    public Element getParent() {
        return parent;
    }

    /**
     * Returns an enumeration of the immediate children of this element
     *
     * @return Enumeration An enumeration containing all of the children of this element.
     *
     * @since JXTA 1.0
     */
    public Enumeration getChildren() {
        return children.elements();
    }

    public String getName() {
        return name;
    }

    public String getTextValue() {
        return val;
    }

    /**
     * Add a child element to this element
     *
     * @param element the element to be added as a child
     */
    public void appendChild( TextElement element ) {
        if( !PlainTextElement.class.isInstance( element ) )
            throw new IllegalArgumentException( "element type not supported." );

        PlainTextElement textElement = (PlainTextElement) element;

        if( textElement.doc != this.doc )
            throw new IllegalArgumentException( "Wrong Document" );

        textElement.parent = this;
        children.addElement( textElement );
    }

    /**
     * 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 ) {
        Vector result = new Vector();

        for( Enumeration eachChild = children.elements(); eachChild.hasMoreElements(); ) {
            TextElement aChild = (TextElement) eachChild.nextElement();

            if( name.equals( aChild.getName() ) )
                result.addElement( aChild );
        }

        return result.elements();
    }

    /**
     *  Write the contents of this element and optionally its children. The
     *  writing is done to a provided java.io.Writer. The writing can optionally
     *  be indented
     *
     *  @param into The java.io.Writer that the output will be sent to.
     *  @param indent   the number of tabs which will be inserted before each
     *      line.
     *  @param recurse  if true then also print the children of this element.
     *
     **/
    protected void printNice( Writer into, int indent, boolean recurse ) {

        try {
            // do indent
            for( int eachTab = 0; eachTab < indent; eachTab++ )
                into.write( "\t" );

            // print node name
            into.write( name  );

            // print attributes
            Enumeration attributes = getAttributes();

            if( attributes.hasMoreElements() ) {
                into.write( "(" );

                while( attributes.hasMoreElements() ) {
                    Attribute anAttr = (Attribute) attributes.nextElement();
                    into.write( anAttr.getName() + "=\"" + anAttr.getValue() + "\" " );
                }
                into.write( ")" );
            }

            into.write(  " : " );
            // print node value
            if ( null != val )
                into.write( val + "\n" );
            else
                into.write(  "\n" );

            // recurse as needed
            if ( recurse )
                for( Enumeration childrens = getChildren() ; childrens.hasMoreElements(); )
                    ((PlainTextElement)childrens.nextElement()).printNice( into, indent + 1, recurse );
        }
        catch( IOException ignored ) {
            // we ignore any io errors
        }
    }

    // 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 = (String) attributes.remove( name );
        attributes.put( name, value );

        return  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) {
        return addAttribute(newAttrib.getName(), newAttrib.getValue());
    }

    /**
     *  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() {

        Vector attrs = new Vector();
        //PDA requirements 19.02.2002
        //java.util.Iterator -> java.util.Enumeration
        //for (Iterator eachAttr = attributes.entrySet().iterator();
        for (Enumeration eachAttr = attributes.keys();
            //eachAttr.hasNext(); ) {
            eachAttr.hasMoreElements(); ) {
                //Map.Entry anAttr = (Map.Entry) eachAttr.next();
                Object key = eachAttr.nextElement();
                Object value = attributes.get(key);

            Attribute attr = new Attribute(this,
                                           //(String) anAttr.getKey(),
                                           (String)key,
                                           //(String) anAttr.getValue() );
                                           (String)value);
            attrs.addElement(attr);
        }
        //PDA requirements 19.02.2002

        return attrs.elements();
    }

    /**
     *  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) {
        String value = (String) attributes.get( name );

        if( null == value )
            return null;

        // build the object
        return new Attribute( this, name , value );
    }
}