Node represents a node in a document tree.
*
* @author Michael Fuchs
* @version 1.0
*/
public class NodeImpl implements Node {
public static final int FORMAT_BLOCK = 3;
public static final int FORMAT_CONTENT = 2;
public static final int FORMAT_INLINE = 1;
public static final int HTML = 3;
private static Log logger = LogFactory.getLog(NodeImpl.class);
private static final String LSEP = System.getProperty("line.separator");
public static final int SGML = 1;
public static final int XML = 2;
private static int flavour = XML;
public static final short XML_DECLARATION = 23;
private NodeListImpl childNodes = new NodeListImpl();
private int column;
private DocumentImpl document;
protected boolean isCaseInsensitive = false;
private boolean isEmpty = false;
private boolean isMute = false;
private boolean isRawData = false;
private int line;
private String namespaceUri;
private boolean needsPadding = false;
private String nodeName = "node";
private short nodeType = ELEMENT_NODE;
private String nodeValue;
private NodeImpl parent = null;
private String prefix;
private HashMapfindParent tries to find the nearest parent,
* which is of type parentClass.
*
* If no parent of this type can be found null is returned.
*
* @param node
* a Node value
* @param parentClass
* a Class value
* @return a Node value
*/
public static NodeImpl findParent(Node node, Class parentClass) {
if (node == null || parentClass == null) {
return null;
}
Node parent = node.getParentNode();
while (parent != null && !parentClass.isInstance(parent)) {
parent = parent.getParentNode();
}
return (NodeImpl) parent;
}
public static String getTextContent(NodeImpl node) {
String buffer = "";
if (node instanceof TextImpl) {
buffer += ((TextImpl) node).getData();
}
NodeListImpl children = node.getTrafoChildNodes();
if (children == null) {
return buffer;
}
IteratorappendChild adds a child node to this node.
*
* The parent of the child node is explicitly set to this node to this node
* to avoid inconsistencies in the resulting document tree.
*
* @param node
* The child node {@link NodeImpl (Node)}.
*/
public NodeImpl appendChild(NodeImpl node) {
if (node == null) {
throw new IllegalArgumentException("Variable node is null!");
}
if (childNodes == null) {
throw new IllegalStateException("Variable childNodes is null!");
}
node.setParentNode(this);
if (node instanceof DocumentFragment) {
NodeList childList = node.getChildNodes();
for (int i=0; igetChildNodes returns a list with all children of
* this node..
*
* @return an ArrayList value
*/
@Override
public NodeList getChildNodes() {
if (childNodes == null) {
throw new IllegalStateException("Variable childNodes is null!");
}
return childNodes;
}
public int getColumn() {
return column;
}
public DocumentImpl getDocument() {
if (document == null) {
Node parent = getParentNode();
while (parent != null && document == null) {
document = (DocumentImpl) parent.getOwnerDocument();
parent = parent.getParentNode();
}
}
if (document == null) {
document = new DocumentImpl();
}
return document;
}
public NodeListImpl getElementChildNodes() {
if (childNodes == null) {
throw new IllegalStateException("Variable childNodes is null!");
}
NodeListImpl list = new NodeListImpl();
for (int i = 0; i < childNodes.getLength(); i++) {
Node child = childNodes.item(i);
if (child instanceof ElementImpl) {
list.add((NodeImpl) child);
}
}
return list;
}
@Override
public Object getFeature(String feature, String version) {
System.err.println("Not yet implemented");
return null;
}
/**
* The method getFirstChild returns the first child of this
* node.
*
* If this node has no children, null is returned.
*
* @return a Node value
*/
@Override
public NodeImpl getFirstChild() {
if (childNodes == null || childNodes.size() < 1) {
return null;
}
return childNodes.get(0);
}
/**
* The method getFirstElement returns the first child of this
* node that is of type ELEMENT_NODE.
*
* If this node has no element child, null is returned.
*
* @return The element or null, if element child can be found.
*/
public Element getFirstChildElement() {
if ((childNodes == null) || (childNodes.size() < 1)) {
return null;
}
NodeImpl element = null;
for (int i = 0; i < childNodes.size(); i++) {
if (childNodes.get(i) instanceof ElementImpl) {
element = childNodes.get(i);
break;
}
}
return (Element) element;
}
public Text getFirstText() {
if ((childNodes == null) || (childNodes.size() < 1)) {
return null;
}
NodeImpl element = null;
for (int i = 0; i < childNodes.size(); i++) {
if (childNodes.get(i) instanceof Text) {
element = childNodes.get(i);
break;
}
}
return (Text) element;
}
/* ========================================================== */
/* Extensions */
/* ========================================================== */
public int getFlavour() {
return flavour;
}
@Override
public Node getLastChild() {
if (childNodes == null || childNodes.size() == 0) {
return null;
}
return childNodes.get(childNodes.size() - 1);
}
public NodeImpl getLastChild(Class type) {
if (type == null) {
throw new IllegalArgumentException(
"The argument type must not be null!");
}
if ((childNodes == null) || (childNodes.size() < 1)) {
return null;
}
NodeImpl element = null;
NodeImpl node;
String classname;
for (int i = 0; i < childNodes.size(); i++) {
node = childNodes.get(i);
classname = node.getClass().getName();
if (classname.equals(type.getName())) {
element = childNodes.get(i);
}
}
return element;
}
public int getLine() {
return line;
}
@Override
public String getLocalName() {
if (this instanceof ElementImpl || this instanceof AttrImpl
|| this instanceof EntityImpl) {
String qualifiedName = getNodeName();
if (qualifiedName.indexOf(':') == -1) {
return qualifiedName;
} else {
return qualifiedName.split(":")[1];
}
}
return null;
}
@Override
public String getNamespaceURI() {
return namespaceUri;
}
@Override
public Node getNextSibling() {
NodeImpl parent = getTrafoParentNode();
if (parent == null) {
return null;
}
int index = 0;
NodeListImpl children = parent.getTrafoChildNodes();
for (NodeImpl child : children) {
if (child == this) {
break;
}
index++;
}
if (index < (children.size() - 1)) {
return children.get(index + 1);
}
return null;
}
@Override
public String getNodeName() {
return nodeName;
}
@Override
public short getNodeType() {
return nodeType;
}
@Override
public String getNodeValue() throws DOMException {
return nodeValue;
}
public int getNumberOfChildNodes() {
return childNodes.size();
}
@Override
public Document getOwnerDocument() {
return getDocument();
}
@Override
public Node getParentNode() {
return parent;
}
@Override
public String getPrefix() {
if (prefix != null) {
return prefix;
}
if (this instanceof ElementImpl || this instanceof AttrImpl) {
String qualifiedName = getNodeName();
if (qualifiedName.indexOf(':') == -1) {
return null;
} else {
return qualifiedName.split(":")[0];
}
}
return null;
}
@Override
public Node getPreviousSibling() {
NodeImpl parent = getTrafoParentNode();
if (parent == null) {
return null;
}
int index = 0;
NodeListImpl children = parent.getTrafoChildNodes();
for (NodeImpl child : children) {
if (child == this) {
break;
}
index++;
}
if (index > 0) {
return children.get(index - 1);
}
return null;
}
public NodeImpl getRoot() {
Node parent = getParentNode();
if (parent == null) {
return this;
}
Node root = parent;
while (parent != null) {
parent = parent.getParentNode();
if (parent != null) {
root = parent;
}
}
return (NodeImpl) root;
}
@Override
public String getTextContent() {
return NodeImpl.getTextContent(this);
}
public NodeListImpl getTrafoChildNodes() {
if (childNodes == null) {
childNodes = new NodeListImpl();
}
return childNodes;
}
public NodeImpl getTrafoParentNode() {
return parent;
}
@Override
public Object getUserData(String key) {
if (key == null || userDataMap == null) {
return null;
}
return userDataMap.get(key);
}
public String hardenText(String text) {
if (text == null) {
return "";
}
String buffer = StringServices.replace(text, "&", "&");
buffer = StringServices.replace(buffer, "<", "<");
buffer = StringServices.replace(buffer, ">", ">");
return buffer;
}
@Override
public boolean hasAttributes() {
System.err.println("Not yet implemented");
return false;
}
/**
* The method hasChildren returns true, if the node contains
* any children.
*
* @return an int value
*/
@Override
public boolean hasChildNodes() {
if (childNodes == null) {
throw new IllegalStateException("Parameter childNodes is null!");
}
int size = childNodes.size();
if (size > 0) {
return true;
} else {
return false;
}
}
/**
* The method hasElementChildren returns true, if the node
* contains any children, which are elements.
*
* @return an int value
*/
public boolean hasElementChildren() {
if (childNodes == null) {
throw new IllegalStateException("Parameter childNodes is null!");
}
NodeImpl node;
for (int i = 0; i < childNodes.size(); i++) {
node = childNodes.get(i);
if (node instanceof ElementImpl) {
return true;
}
}
return false;
}
public boolean hasSiblingElements() {
NodeImpl parent = (NodeImpl) getParentNode();
if (parent == null) {
return false;
}
NodeListImpl list = parent.getElementChildNodes();
for (int i = 0; i < list.getLength(); i++) {
Node node = list.get(i);
if (node != this) {
return true;
}
}
return false;
}
public boolean hasText() {
String text = getTextContent();
if ((text != null) && !text.trim().equals("")) {
return true;
}
return false;
}
public Node insertAfter(Node newChild, Node refChild) {
if (newChild == null) {
throw new IllegalArgumentException(
"The argument newChild must not be null!");
}
if (refChild == null) {
throw new IllegalArgumentException(
"The argument refChild must not be null!");
}
NodeImpl node;
int index = -1;
if ((childNodes != null) && (childNodes.size() > 0)) {
for (int i = 0; i < childNodes.size(); i++) {
node = childNodes.get(i);
if (node == refChild) {
index = i;
}
}
if (index > -1) {
NodeImpl newChildImpl = (NodeImpl) newChild;
newChildImpl.setParentNode(this);
childNodes.add(index + 1, newChildImpl);
}
}
return this;
}
@Override
public Node insertBefore(Node newChild, Node refChild) throws DOMException {
NodeListImpl childList = (NodeListImpl) getChildNodes();
for (int i = 0; i < childList.getLength(); i++) {
Node child = childList.item(i);
if (child.equals(refChild)) {
NodeImpl newChildImpl = (NodeImpl) newChild;
newChildImpl.setParentNode(this);
logger.debug("Inserting " + newChild + "before " + refChild);
childList.add(i, newChildImpl);
return this;
}
}
logger.warn("InsertBefore: Couldn't find reference child " + refChild);
return this;
}
/**
* The method insertChild inserts a child node at the specified
* index.
*
* @param index
* an int value
* @param node
* a Node value
* @return a Node value
*/
public NodeImpl insertChild(int index, NodeImpl node) {
node.setParentNode(this);
childNodes.add(index, node);
return this;
}
/**
* Falls die Sprache nicht zwischen Groß- und Kleinschreibung unterscheidet,
* muss das Attribute isCaseSensitive auf true
* gesetzt werden.
*
*
* Die Methode konvertiert bereits bestehende Daten in Kleinbuchstaben.
* Sollten dabei Doppeldeutigkeiten auftreten, gilt der letzte, verarbeitete
* Wert.
*
* @param isCaseInsensitive
* @return NodeImpl
*/
public NodeImpl isCaseInsensitive(boolean isCaseInsensitive) {
this.isCaseInsensitive = isCaseInsensitive;
if (nodeName != null) {
nodeName = nodeName.toLowerCase();
}
return this;
}
@Override
public boolean isDefaultNamespace(String namespaceURI) {
System.err.println("Not yet implemented");
return false;
}
public boolean isEmpty() {
return isEmpty;
}
public NodeImpl isEmpty(boolean isEmpty) {
this.isEmpty = isEmpty;
return this;
}
@Override
public boolean isEqualNode(Node otherNode) {
return equals(otherNode);
}
public boolean isMute() {
return isMute;
}
public void isMute(boolean isMute) {
this.isMute = isMute;
}
public boolean isRawData() {
return isRawData;
}
public void isRawData(boolean isRawData) {
this.isRawData = isRawData;
}
/**
* The method isRoot returns true if this node is Root
* node.
*
* @return a boolean value
*/
public boolean isRoot() {
if (parent == null || this instanceof DocumentFragmentImpl) {
return true;
}
return false;
}
@Override
public boolean isSameNode(Node other) {
System.err.println("Not yet implemented");
return false;
}
@Override
public boolean isSupported(String feature, String version) {
System.err.println("Not yet implemented");
return false;
}
@Override
public String lookupNamespaceURI(String prefix) {
System.err.println("Not yet implemented");
return null;
}
@Override
public String lookupPrefix(String namespaceURI) {
System.err.println("Not yet implemented");
return null;
}
public boolean needsPadding() {
return needsPadding;
}
public NodeImpl needsPadding(boolean needsPadding) {
this.needsPadding = needsPadding;
return this;
}
@Override
public void normalize() {
System.err.println("Not yet implemented");
}
@Override
public Node removeChild(Node node) throws DOMException {
if (node == null) {
throw new IllegalArgumentException("Variable node is null!");
}
if (childNodes == null) {
throw new IllegalStateException("Variable childNodes is null!");
}
Node child;
Node removedChild = null;
for (int i = 0; i < childNodes.getLength(); i++) {
child = childNodes.item(i);
if (child.equals(node)) {
childNodes.remove(i);
removedChild = child;
break;
}
}
return removedChild;
}
/**
* {@inheritDoc}
*
* The method replaceChild exchanges a node against another
* one.
*
* Beware of that the parent of the old child is set to null. If either
* oldNode or newNode is null, an
* IllegalArgumentException is thrown.
*
* @param oldChild
* a Node value
* @param newChild
* a Node value
* @return a Node value
*/
@Override
public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
logger.debug("(W3C) Replacing child " + oldChild + " with child "
+ newChild);
NodeList childList = getChildNodes();
for (int i = 0; i < childList.getLength(); i++) {
Node child = childList.item(i);
if (child.equals(oldChild)) {
logger.debug("Found child to replace.");
insertBefore(newChild, oldChild);
removeChild(oldChild);
}
}
return this;
}
public void setChildNodes(NodeList children) {
if (children == null) {
childNodes = new NodeListImpl();
}
childNodes = (NodeListImpl) children;
}
/**
* Die Methode setColumn setzt die Spaltennummer in der das
* Element ursprünglich vom Tokenizer gefunden wurde.
*
* @param column
* int
*/
public void setColumn(int column) {
this.column = column;
}
public void setDocument(DocumentImpl document) {
this.document = document;
}
/**
* Die Methode setLine setzt die Zeilennummer in der das
* Element ursprünglich vom Tokenizer gefunden wurde.
*
* @param line
* int
*/
public void setLine(int line) {
this.line = line;
}
public void setMute(boolean isMute) {
this.isMute = isMute;
}
public void setNamespaceURI(String namespaceUri) {
this.namespaceUri = namespaceUri;
}
public void setNodeName(String nodeName) {
this.nodeName = nodeName;
}
public void setNodeType(short nodeType) {
this.nodeType = nodeType;
}
@Override
public void setNodeValue(String nodeValue) throws DOMException {
this.nodeValue = nodeValue;
}
public void setParentNode(NodeImpl parent) {
if (this == parent) {
throw new IllegalStateException("Self referencing " + parent);
}
this.parent = parent;
}
@Override
public void setPrefix(String prefix) throws DOMException {
this.prefix = prefix;
}
@Override
public void setTextContent(String textContent) throws DOMException {
childNodes.clear();
if (textContent != null) {
if (this instanceof TextImpl) {
((TextImpl) this).setData(textContent);
} else {
appendChild(new TextImpl(textContent));
}
}
}
@Override
public Object setUserData(String key, Object data, UserDataHandler handler) {
if (userDataMap == null) {
userDataMap = new HashMap