/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999 The Apache Software Foundation. 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 acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* 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 THE APACHE SOFTWARE FOUNDATION 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 the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
This class was derived from org.apache.jasper.xmlparser.TreeNode;
*/
package tk.teutoburgo.jsitemap;
import java.util.Vector;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Enumeration;
/**
* Simplified implementation of a Node from a Document Object Model (DOM)
* parse of an XML document. This class is used to represent a DOM tree
* so that the XML parser's implementation of <code>org.w3c.dom</code> need
* not be visible to the remainder of Jasper.
* <p>
* <strong>WARNING</strong> - Construction of a new tree, or modifications
* to an existing one, are not thread-safe and such accesses must be
* synchronized.
*
* @author Craig R. McClanahan, Pierre Blanc
* @version $Revision: 1.1.1.1 $ $Date: 2003/03/03 18:46:20 $
*/
public class TeutoTreeNode {
// ----------------------------------------------------------- Constructors
/**
* Construct a new node with no parent.
*
* @param name The name of this node
*/
public TeutoTreeNode
(String name
) {
this(name, null);
}
/**
* Construct a new node with the specified parent.
*
* @param name The name of this node
* @param parent The node that is the parent of this node
*/
public TeutoTreeNode
(String name, TeutoTreeNode parent
) {
super();
this.name = name;
this.parent = parent;
if (this.parent != null)
this.parent.addChild(this);
}
// ----------------------------------------------------- Instance Variables
/**
* The attributes of this node, keyed by attribute name,
* Instantiated only if required.
*/
/**
* The body text associated with this node (if any).
*/
/**
* The children of this node, instantiated only if required.
*/
protected Vector children
= null;
/**
* The name of this node.
*/
/**
* The parent node of this node.
*/
protected TeutoTreeNode parent = null;
// --------------------------------------------------------- Public Methods
/**
* Add an attribute to this node, replacing any existing attribute
* with the same name.
*
* @param name The attribute name to add
* @param value The new attribute value
*/
if (attributes == null)
attributes.put(name, value);
}
/**
* Add a new child node to this node.
*
* @param node The new child node
*/
public void addChild(TeutoTreeNode node) {
if (children == null)
children.addElement(node);
}
/**
* Return the value of the specified node attribute if it exists, or
* <code>null</code> otherwise.
*
* @param name Name of the requested attribute
*/
if (attributes == null)
return (null);
else
return ((String) attributes.
get(name
));
}
/**
* Return an Enumeration of the attribute names of this node. If there are
* no attributes, an empty Enumeration is returned.
*/
if (attributes == null)
return (null);
else
return (attributes.elements());
}
/**
* Return the first child node of this node with the specified name,
* if there is one; otherwise, return <code>null</code>.
*
* @param name Name of the desired child element
*/
public TeutoTreeNode findChild
(String name
) {
if (children == null)
return (null);
while (items.hasMoreElements()) {
TeutoTreeNode item = (TeutoTreeNode) items.nextElement();
if (name.equals(item.getName()))
return (item);
}
return (null);
}
/**
* Return an Enumeration of all children of this node. If there are no
* children, an empty Enumeration is returned.
*/
if (children == null)
return (null);
else
return (children.elements());
}
/**
* Return an Enumeration over all children of this node that have the
* specified name. If there are no such children, an empty Enumeration
* is returned.
*
* @param name Name used to select children
*/
/* public Enumeration findChildren(String name) {
if (children == null)
return (null);
Vector results = new Vector();
Enumeration items = children.iterator();
while (items.hasMoreElements()) {
TeutoTreeNode item = (TeutoTreeNode) items.nextElement();
if (name.equals(item.getName()))
results.addElement(item);
}
return (results.iterator());
}*/
/**
* Return the body text associated with this node (if any).
*/
return (this.body);
}
/**
* Return the name of this node.
*/
return (this.name);
}
/**
* Remove any existing value for the specified attribute name.
*
* @param name The attribute name to remove
*/
public void removeAttribute
(String name
) {
if (attributes != null)
attributes.remove(name);
}
/**
* Remove a child node from this node, if it is one.
*
* @param node The child node to remove
*/
public void removeNode(TeutoTreeNode node) {
if (children != null)
children.remove(node);
}
/**
* Set the body text associated with this node (if any).
*
* @param body The body text (if any)
*/
public void setBody
(String body
) {
this.body = body;
}
/**
* Return a String representation of this TeutoTreeNode.
*/
toString(sb, 0, this);
return (sb.toString());
}
// ------------------------------------------------------ Protected Methods
/**
* Append to the specified StringBuffer a character representation of
* this node, with the specified amount of indentation.
*
* @param sb The StringBuffer to append to
* @param indent Number of characters of indentation
* @param node The TeutoTreeNode to be printed
*/
TeutoTreeNode node) {
int indent2 = indent + 2;
// Reconstruct an opening node
for (int i = 0; i < indent; i++)
sb.append(' ');
sb.append('<');
sb.append(node.getName());
if(names!=null)
while (names.hasMoreElements()) {
sb.append(' ');
sb.append(name);
sb.append("=\"");
String value
= node.
findAttribute(name
); sb.append(value);
sb.append("\"");
}
sb.append(">\n");
// Reconstruct the body text of this node (if any)
if ((body != null) && (body.length() > 0)) {
for (int i = 0; i < indent2; i++)
sb.append(' ');
sb.append(body);
sb.append("\n");
}
// Reconstruct child nodes with extra indentation
while (children.hasMoreElements()) {
TeutoTreeNode child = (TeutoTreeNode) children.nextElement();
toString(sb, indent2, child);
}
// Reconstruct a closing node marker
for (int i = 0; i < indent; i++)
sb.append(' ');
sb.append("</");
sb.append(node.getName());
sb.append(">\n");
}
}
