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