| /* Copyright (c) 2002,2003, Stefan Haustein, Oberhausen, Rhld., Germany |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. */ |
| |
| package org.kxml2.kdom; |
| |
| import java.io.*; |
| import java.util.*; |
| |
| import org.xmlpull.v1.*; |
| |
| /** |
| * In order to create an element, please use the createElement method |
| * instead of invoking the constructor directly. The right place to |
| * add user defined initialization code is the init method. */ |
| |
| public class Element extends Node { |
| |
| protected String namespace; |
| protected String name; |
| protected Vector attributes; |
| protected Node parent; |
| protected Vector prefixes; |
| |
| public Element() { |
| } |
| |
| /** |
| * called when all properties are set, but before children |
| * are parsed. Please do not use setParent for initialization |
| * code any longer. */ |
| |
| public void init() { |
| } |
| |
| |
| |
| |
| /** |
| * removes all children and attributes */ |
| |
| public void clear() { |
| attributes = null; |
| children = null; |
| } |
| |
| /** |
| * Forwards creation request to parent if any, otherwise |
| * calls super.createElement. */ |
| |
| public Element createElement( |
| String namespace, |
| String name) { |
| |
| return (this.parent == null) |
| ? super.createElement(namespace, name) |
| : this.parent.createElement(namespace, name); |
| } |
| |
| /** |
| * Returns the number of attributes of this element. */ |
| |
| public int getAttributeCount() { |
| return attributes == null ? 0 : attributes.size(); |
| } |
| |
| public String getAttributeNamespace (int index) { |
| return ((String []) attributes.elementAt (index)) [0]; |
| } |
| |
| /* public String getAttributePrefix (int index) { |
| return ((String []) attributes.elementAt (index)) [1]; |
| }*/ |
| |
| public String getAttributeName (int index) { |
| return ((String []) attributes.elementAt (index)) [1]; |
| } |
| |
| |
| public String getAttributeValue (int index) { |
| return ((String []) attributes.elementAt (index)) [2]; |
| } |
| |
| |
| public String getAttributeValue (String namespace, String name) { |
| for (int i = 0; i < getAttributeCount (); i++) { |
| if (name.equals (getAttributeName (i)) |
| && (namespace == null || namespace.equals (getAttributeNamespace(i)))) { |
| return getAttributeValue (i); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the root node, determined by ascending to the |
| * all parents un of the root element. */ |
| |
| public Node getRoot() { |
| |
| Element current = this; |
| |
| while (current.parent != null) { |
| if (!(current.parent instanceof Element)) return current.parent; |
| current = (Element) current.parent; |
| } |
| |
| return current; |
| } |
| |
| /** |
| * returns the (local) name of the element */ |
| |
| public String getName() { |
| return name; |
| } |
| |
| /** |
| * returns the namespace of the element */ |
| |
| public String getNamespace() { |
| return namespace; |
| } |
| |
| |
| /** |
| * returns the namespace for the given prefix */ |
| |
| public String getNamespaceUri (String prefix) { |
| int cnt = getNamespaceCount (); |
| for (int i = 0; i < cnt; i++) { |
| if (prefix == getNamespacePrefix (i) || |
| (prefix != null && prefix.equals (getNamespacePrefix (i)))) |
| return getNamespaceUri (i); |
| } |
| return parent instanceof Element ? ((Element) parent).getNamespaceUri (prefix) : null; |
| } |
| |
| |
| /** |
| * returns the number of declared namespaces, NOT including |
| * parent elements */ |
| |
| public int getNamespaceCount () { |
| return (prefixes == null ? 0 : prefixes.size ()); |
| } |
| |
| |
| public String getNamespacePrefix (int i) { |
| return ((String []) prefixes.elementAt (i)) [0]; |
| } |
| |
| public String getNamespaceUri (int i) { |
| return ((String []) prefixes.elementAt (i)) [1]; |
| } |
| |
| |
| /** |
| * Returns the parent node of this element */ |
| |
| public Node getParent() { |
| return parent; |
| } |
| |
| /* |
| * Returns the parent element if available, null otherwise |
| |
| public Element getParentElement() { |
| return (parent instanceof Element) |
| ? ((Element) parent) |
| : null; |
| } |
| */ |
| |
| /** |
| * Builds the child elements from the given Parser. By overwriting |
| * parse, an element can take complete control over parsing its |
| * subtree. */ |
| |
| public void parse(XmlPullParser parser) |
| throws IOException, XmlPullParserException { |
| |
| for (int i = parser.getNamespaceCount (parser.getDepth () - 1); |
| i < parser.getNamespaceCount (parser.getDepth ()); i++) { |
| setPrefix (parser.getNamespacePrefix (i), parser.getNamespaceUri(i)); |
| } |
| |
| |
| for (int i = 0; i < parser.getAttributeCount (); i++) |
| setAttribute (parser.getAttributeNamespace (i), |
| // parser.getAttributePrefix (i), |
| parser.getAttributeName (i), |
| parser.getAttributeValue (i)); |
| |
| |
| // if (prefixMap == null) throw new RuntimeException ("!!"); |
| |
| init(); |
| |
| |
| if (parser.isEmptyElementTag()) |
| parser.nextToken (); |
| else { |
| parser.nextToken (); |
| super.parse(parser); |
| |
| if (getChildCount() == 0) |
| addChild(IGNORABLE_WHITESPACE, ""); |
| } |
| |
| parser.require( |
| XmlPullParser.END_TAG, |
| getNamespace(), |
| getName()); |
| |
| parser.nextToken (); |
| } |
| |
| |
| /** |
| * Sets the given attribute; a value of null removes the attribute */ |
| |
| public void setAttribute (String namespace, String name, String value) { |
| if (attributes == null) |
| attributes = new Vector (); |
| |
| if (namespace == null) |
| namespace = ""; |
| |
| for (int i = attributes.size()-1; i >=0; i--){ |
| String[] attribut = (String[]) attributes.elementAt(i); |
| if (attribut[0].equals(namespace) && |
| attribut[1].equals(name)){ |
| |
| if (value == null) { |
| attributes.removeElementAt(i); |
| } |
| else { |
| attribut[2] = value; |
| } |
| return; |
| } |
| } |
| |
| attributes.addElement |
| (new String [] {namespace, name, value}); |
| } |
| |
| |
| /** |
| * Sets the given prefix; a namespace value of null removess the |
| * prefix */ |
| |
| public void setPrefix (String prefix, String namespace) { |
| if (prefixes == null) prefixes = new Vector (); |
| prefixes.addElement (new String [] {prefix, namespace}); |
| } |
| |
| |
| /** |
| * sets the name of the element */ |
| |
| public void setName(String name) { |
| this.name = name; |
| } |
| |
| /** |
| * sets the namespace of the element. Please note: For no |
| * namespace, please use Xml.NO_NAMESPACE, null is not a legal |
| * value. Currently, null is converted to Xml.NO_NAMESPACE, but |
| * future versions may throw an exception. */ |
| |
| public void setNamespace(String namespace) { |
| if (namespace == null) |
| throw new NullPointerException ("Use \"\" for empty namespace"); |
| this.namespace = namespace; |
| } |
| |
| /** |
| * Sets the Parent of this element. Automatically called from the |
| * add method. Please use with care, you can simply |
| * create inconsitencies in the document tree structure using |
| * this method! */ |
| |
| protected void setParent(Node parent) { |
| this.parent = parent; |
| } |
| |
| |
| /** |
| * Writes this element and all children to the given XmlWriter. */ |
| |
| public void write(XmlSerializer writer) |
| throws IOException { |
| |
| if (prefixes != null) { |
| for (int i = 0; i < prefixes.size(); i++) { |
| writer.setPrefix (getNamespacePrefix (i), getNamespaceUri (i)); |
| } |
| } |
| |
| writer.startTag( |
| getNamespace(), |
| getName()); |
| |
| int len = getAttributeCount(); |
| |
| for (int i = 0; i < len; i++) { |
| writer.attribute( |
| getAttributeNamespace(i), |
| getAttributeName(i), |
| getAttributeValue(i)); |
| } |
| |
| writeChildren(writer); |
| |
| writer.endTag(getNamespace (), getName ()); |
| } |
| } |