/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cocoon.xml.dom;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.xml.IncludeXMLConsumer;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.SourceParameters;
import org.apache.excalibur.xml.sax.SAXParser;
import org.apache.excalibur.xml.sax.XMLizable;
import org.apache.excalibur.xml.xpath.NodeListImpl;
import org.apache.excalibur.xml.xpath.XPathProcessor;
import org.apache.excalibur.xml.xpath.XPathUtil;
import org.apache.xpath.XPathAPI;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerException;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;
/**
* This class is a utility class for miscellaneous DOM functions, like getting
* and setting values of nodes.
*
* @author <a href="mailto:cziegeler@s-und-n.de">Carsten Ziegeler</a>
* @version $Id$
*/
public final class DOMUtil {
private static final String XPATH_IS_REQUIRED = "XPath is required.";
/**
* Get the owner of the DOM document belonging to the node. This works even
* if the node is the document itself.
*
* @param node
* The node.
* @return The corresponding document.
*/
public static Document getOwnerDocument(Node node) {
if (node.getNodeType() == Node.DOCUMENT_NODE) {
return (Document) node;
} else {
return node.getOwnerDocument();
}
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node does not exist <CODE>null</CODE> is
* returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @return The value of the node or <CODE>null</CODE>
*/
public static String getValueOfNode(XPathProcessor processor, Node root, String path) throws ProcessingException {
if (path == null) {
throw new ProcessingException(XPATH_IS_REQUIRED);
}
if (root != null) {
path = StringUtils.strip(path, "/");
Node node = XPathUtil.searchSingleNode(processor, root, path);
if (node != null) {
return getValueOfNode(node);
}
}
return null;
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node is not found the <CODE>defaultValue</CODE>
* is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* The default value if the node does not exist.
* @return The value of the node or <CODE>defaultValue</CODE>
*/
public static String getValueOfNode(XPathProcessor processor, Node root, String path, String defaultValue)
throws ProcessingException {
String value = getValueOfNode(processor, root, path);
if (value == null)
value = defaultValue;
return value;
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @return The boolean value of the node.
* @throws ProcessingException
* If the node is not found.
*/
public static boolean getValueOfNodeAsBoolean(XPathProcessor processor, Node root, String path)
throws ProcessingException {
String value = getValueOfNode(processor, root, path);
if (value == null) {
throw new ProcessingException("No such node: " + path);
}
return Boolean.valueOf(value).booleanValue();
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values. If the node does not exist,
* the <CODE>defaultValue</CODE> is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* Default boolean value.
* @return The value of the node or <CODE>defaultValue</CODE>
*/
public static boolean getValueOfNodeAsBoolean(XPathProcessor processor, Node root, String path, boolean defaultValue)
throws ProcessingException {
String value = getValueOfNode(processor, root, path);
if (value != null) {
return BooleanUtils.toBoolean(value);
}
return defaultValue;
}
/**
* Get the value of the DOM node. The value of a node is the content of the
* first text node. If the node has no text nodes, <code>null</code> is
* returned.
*/
public static String getValueOfNode(Node node) {
if (node != null) {
if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
return node.getNodeValue();
} else {
node.normalize();
NodeList childs = node.getChildNodes();
int i = 0;
int length = childs.getLength();
while (i < length) {
if (childs.item(i).getNodeType() == Node.TEXT_NODE) {
return childs.item(i).getNodeValue().trim();
} else {
i++;
}
}
}
}
return null;
}
/**
* Get the value of the node. The value of the node is the content of the
* first text node. If the node has no text nodes the <CODE>defaultValue</CODE>
* is returned.
*/
public static String getValueOfNode(Node node, String defaultValue) {
return StringUtils.defaultString(getValueOfNode(node), defaultValue);
}
/**
* Set the value of the DOM node. All current children of the node are
* removed and a new text node with the value is appended.
*/
public static void setValueOfNode(Node node, String value) {
if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
node.setNodeValue(value);
} else {
while (node.hasChildNodes()) {
node.removeChild(node.getFirstChild());
}
node.appendChild(node.getOwnerDocument().createTextNode(value));
}
}
/** XML definition for a document */
private static final String XML_DEFINITION = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
private static final String XML_ROOT_DEFINITION = XML_DEFINITION + "<root>";
/**
* Get a document fragment from a <code>Reader</code>. The reader must
* provide valid XML, but it is allowed that the XML has more than one root
* node. This xml is parsed by the specified parser instance and a DOM
* DocumentFragment is created.
*/
public static DocumentFragment getDocumentFragment(SAXParser parser, Reader stream) throws ProcessingException {
DocumentFragment frag = null;
Writer writer;
Reader reader;
boolean removeRoot = true;
try {
// create a writer,
// write the root element, then the input from the
// reader
writer = new StringWriter();
writer.write(XML_ROOT_DEFINITION);
char[] cbuf = new char[16384];
int len;
do {
len = stream.read(cbuf, 0, 16384);
if (len != -1) {
writer.write(cbuf, 0, len);
}
} while (len != -1);
writer.write("</root>");
// now test if xml input start with <?xml
String xml = writer.toString();
String searchString = XML_ROOT_DEFINITION + "<?xml ";
if (xml.startsWith(searchString)) {
// now remove the surrounding root element
xml = xml.substring(XML_ROOT_DEFINITION.length(), xml.length() - 7);
removeRoot = false;
}
reader = new StringReader(xml);
InputSource input = new InputSource(reader);
DOMBuilder builder = new DOMBuilder();
builder.startDocument();
builder.startElement("", "root", "root", XMLUtils.EMPTY_ATTRIBUTES);
IncludeXMLConsumer filter = new IncludeXMLConsumer(builder, builder);
parser.parse(input, filter);
builder.endElement("", "root", "root");
builder.endDocument();
// Create Document Fragment, remove <root>
final Document doc = builder.getDocument();
frag = doc.createDocumentFragment();
final Node root = doc.getDocumentElement().getFirstChild();
root.normalize();
if (removeRoot == false) {
root.getParentNode().removeChild(root);
frag.appendChild(root);
} else {
Node child;
while (root.hasChildNodes()) {
child = root.getFirstChild();
root.removeChild(child);
frag.appendChild(child);
}
}
} catch (SAXException sax) {
throw new ProcessingException("SAXException: " + sax, sax);
} catch (IOException ioe) {
throw new ProcessingException("IOException: " + ioe, ioe);
}
return frag;
}
/**
* Create a parameter object from xml. The xml is flat and consists of
* elements which all have exactly one text node: <parone>value_one<parone>
* <partwo>value_two<partwo> A parameter can occur more than once with
* different values. If <CODE>source</CODE> is not specified a new
* parameter object is created otherwise the parameters are added to source.
*/
public static SourceParameters createParameters(Node fragment, SourceParameters source) {
SourceParameters par = (source == null ? new SourceParameters() : source);
if (fragment != null) {
NodeList childs = fragment.getChildNodes();
if (childs != null) {
Node current;
for (int i = 0; i < childs.getLength(); i++) {
current = childs.item(i);
// only element nodes
if (current.getNodeType() == Node.ELEMENT_NODE) {
current.normalize();
NodeList valueChilds = current.getChildNodes();
String key;
StringBuffer valueBuffer;
String value;
key = current.getNodeName();
valueBuffer = new StringBuffer();
for (int m = 0; m < valueChilds.getLength(); m++) {
current = valueChilds.item(m); // attention: current is reused here!
if (current.getNodeType() == Node.TEXT_NODE) { // only text nodes
if (valueBuffer.length() > 0)
valueBuffer.append(' ');
valueBuffer.append(current.getNodeValue());
}
}
value = valueBuffer.toString().trim();
if (key != null && value.length() > 0) {
par.setParameter(key, value);
}
}
}
}
}
return par;
}
/**
* Create a string from a DOM document fragment. Only the top level text
* nodes are chained together to build the text.
*/
public static String createText(DocumentFragment fragment) {
StringBuffer value = new StringBuffer();
if (fragment != null) {
NodeList childs = fragment.getChildNodes();
if (childs != null) {
Node current;
for (int i = 0; i < childs.getLength(); i++) {
current = childs.item(i);
// only text nodes
if (current.getNodeType() == Node.TEXT_NODE) {
if (value.length() > 0)
value.append(' ');
value.append(current.getNodeValue());
}
}
}
}
return value.toString().trim();
}
/**
* Compare all attributes of two elements. This method returns true only if
* both nodes have the same number of attributes and the same attributes
* with equal values. Namespace definition nodes are ignored
*/
public static boolean compareAttributes(Element first, Element second) {
NamedNodeMap attr1 = first.getAttributes();
NamedNodeMap attr2 = second.getAttributes();
String value;
if (attr1 == null && attr2 == null)
return true;
int attr1Len = (attr1 == null ? 0 : attr1.getLength());
int attr2Len = (attr2 == null ? 0 : attr2.getLength());
if (attr1Len > 0) {
int l = attr1.getLength();
for (int i = 0; i < l; i++) {
if (attr1.item(i).getNodeName().startsWith("xmlns:"))
attr1Len--;
}
}
if (attr2Len > 0) {
int l = attr2.getLength();
for (int i = 0; i < l; i++) {
if (attr2.item(i).getNodeName().startsWith("xmlns:"))
attr2Len--;
}
}
if (attr1Len != attr2Len)
return false;
int i, l;
int m, l2;
i = 0;
l = attr1.getLength();
l2 = attr2.getLength();
boolean ok = true;
// each attribute of first must be in second with the same value
while (i < l && ok) {
value = attr1.item(i).getNodeName();
if (value.startsWith("xmlns:") == false) {
ok = false;
m = 0;
while (m < l2 && ok == false) {
if (attr2.item(m).getNodeName().equals(value)) {
// same name, same value?
ok = attr1.item(i).getNodeValue().equals(attr2.item(m).getNodeValue());
}
m++;
}
}
i++;
}
return ok;
}
/**
* Implementation for <code>String</code> : outputs characters
* representing the value.
*
* @param parent
* The node getting the value
* @param text
* the value
*/
public static void valueOf(Node parent, String text) throws ProcessingException {
if (text != null) {
parent.appendChild(parent.getOwnerDocument().createTextNode(text));
}
}
/**
* Implementation for <code>XMLizable</code> : outputs the value by
* calling <code>v.toSax(contentHandler)</code>.
*
* @param parent
* The node getting the value
* @param v
* the XML fragment
*/
public static void valueOf(Node parent, XMLizable v) throws ProcessingException {
if (v != null) {
DOMBuilder builder = new DOMBuilder(parent);
try {
v.toSAX(builder);
} catch (SAXException e) {
throw new ProcessingException(e);
}
}
}
/**
* Implementation for <code>org.w3c.dom.Node</code> : converts the Node to
* a SAX event stream.
*
* @param parent
* The node getting the value
* @param v
* the value
*/
public static void valueOf(Node parent, Node v) throws ProcessingException {
if (v != null) {
parent.appendChild(parent.getOwnerDocument().importNode(v, true));
}
}
/**
* Implementation for <code>java.util.Collection</code> : outputs the
* value by calling {@link #valueOf(Node, Object)} on each element of the
* collection.
*
* @param parent
* The node getting the value
* @param v
* the XML fragment
*/
public static void valueOf(Node parent, Collection v) throws ProcessingException {
if (v != null) {
Iterator iterator = v.iterator();
while (iterator.hasNext()) {
valueOf(parent, iterator.next());
}
}
}
/**
* Implementation for <code>java.util.Map</code> : For each entry an
* element is created with the childs key and value Outputs the value and
* the key by calling {@link #valueOf(Node, Object)} on each value and key
* of the Map.
*
* @param parent
* The node getting the value
* @param v
* the Map
*/
public static void valueOf(Node parent, Map v) throws ProcessingException {
if (v != null) {
Node mapNode = parent.getOwnerDocument().createElementNS(null, "java.util.map");
parent.appendChild(mapNode);
for (Iterator iter = v.entrySet().iterator(); iter.hasNext();) {
Map.Entry me = (Map.Entry) iter.next();
Node entryNode = mapNode.getOwnerDocument().createElementNS(null, "entry");
mapNode.appendChild(entryNode);
Node keyNode = entryNode.getOwnerDocument().createElementNS(null, "key");
entryNode.appendChild(keyNode);
valueOf(keyNode, me.getKey());
Node valueNode = entryNode.getOwnerDocument().createElementNS(null, "value");
entryNode.appendChild(valueNode);
valueOf(valueNode, me.getValue());
}
}
}
/**
* Implementation for <code>Object</code> depending on its class :
* <ul>
* <li>if it's an array, call {@link #valueOf(Node, Object)} on all its
* elements,</li>
* <li>if it's class has a specific {@link #valueOf(Node, Object)}
* implementation, use it,</li>
* <li>else, output it's string representation.</li>
* </ul>
*
* @param parent
* The node getting the value
* @param v
* the value
*/
public static void valueOf(Node parent, Object v) throws ProcessingException {
if (v == null) {
return;
}
// Array: recurse over each element
if (v.getClass().isArray()) {
Object[] elements = (Object[]) v;
for (int i = 0; i < elements.length; i++) {
valueOf(parent, elements[i]);
}
return;
}
// Check handled object types in case they were not typed in the XSP
// XMLizable
if (v instanceof XMLizable) {
valueOf(parent, (XMLizable) v);
return;
}
// Node
if (v instanceof Node) {
valueOf(parent, (Node) v);
return;
}
// Collection
if (v instanceof Collection) {
valueOf(parent, (Collection) v);
return;
}
// Map
if (v instanceof Map) {
valueOf(parent, (Map) v);
return;
}
// Give up: hope it's a string or has a meaningful string representation
valueOf(parent, String.valueOf(v));
}
/**
* Use an XPath string to select a single node. XPath namespace prefixes are
* resolved from the context node, which may not be what you want (see the
* next method).
*
* @param contextNode
* The node to start searching from.
* @param str
* A valid XPath string.
* @param processor
* The XPath processor to use
* @return The first node found that matches the XPath, or null.
*
* @throws TransformerException
*/
public static Node getSingleNode(Node contextNode, String str, XPathProcessor processor)
throws TransformerException {
String[] pathComponents = buildPathArray(str);
if (pathComponents == null) {
return processor.selectSingleNode(contextNode, str);
} else {
return getFirstNodeFromPath(contextNode, pathComponents, false);
}
}
/**
* Use an XPath string to select a single node. XPath namespace prefixes are
* resolved from the context node, which may not be what you want (see the
* next method).
*
* @param contextNode
* The node to start searching from.
* @param str
* A valid XPath string.
* @return The first node found that matches the XPath, or null.
*
* @throws TransformerException
* @deprecated. To be removed in 2.2.
*/
public static Node getSingleNode(Node contextNode, String str) throws TransformerException {
String[] pathComponents = buildPathArray(str);
if (pathComponents == null) {
return XPathAPI.selectSingleNode(contextNode, str);
} else {
return getFirstNodeFromPath(contextNode, pathComponents, false);
}
}
/**
* Return the <CODE>Node</CODE> from the DOM Node <CODE>rootNode</CODE>
* using the XPath expression <CODE>path</CODE>. If the node does not
* exist, it is created and then returned. This is a very simple method for
* creating new nodes. If the XPath contains selectors ([,,,]) or "*" it is
* of course not possible to create the new node. So if you use such XPaths
* the node must exist beforehand. An simple exception is if the expression
* contains attribute test to values (e.g. [@id = 'du' and
*
* @number = 'you'], the attributes with the given values are added. The
* attributes must be separated with 'and'. Another problem are
* namespaces: XPath requires sometimes selectors for namespaces,
* e.g. : /*[namespace-uri()="uri" and local-name()="name"] Creating
* such a node with a namespace is not possible right now as we use
* a very simple XPath parser which is not able to parse all kinds
* of selectors correctly.
*
* @param rootNode
* The node to start the search.
* @param path
* XPath expression for searching the node.
* @return The node specified by the path.
* @throws ProcessingException
* If no path is specified or the XPath engine fails.
* @deprecated To be removed in 2.2.
*/
public static Node selectSingleNode(Node rootNode, String path) throws ProcessingException {
// Now we have to parse the string
// First test: path? rootNode?
if (path == null) {
throw new ProcessingException(XPATH_IS_REQUIRED);
}
if (rootNode == null)
return rootNode;
if (path.length() == 0 || path.equals("/"))
return rootNode;
// now the first "quick" test is if the node exists using the
// full XPathAPI
try {
Node testNode = getSingleNode(rootNode, path);
if (testNode != null)
return testNode;
} catch (TransformerException local) {
throw new ProcessingException("Transforming exception during selectSingleNode with path: '" + path
+ "'. Exception: " + local, local);
}
// Remove leading "/" on both ends
path = StringUtils.strip(path, "/");
// now step through the nodes!
Node parent = rootNode;
int pos;
int posSelector;
do {
pos = path.indexOf("/"); // get next separator
posSelector = path.indexOf("[");
if (posSelector != -1 && posSelector < pos) {
posSelector = path.indexOf("]");
pos = path.indexOf("/", posSelector);
}
String nodeName;
boolean isAttribute = false;
if (pos != -1) { // found separator
nodeName = path.substring(0, pos); // string until "/"
path = path.substring(pos + 1); // rest of string after "/"
} else {
nodeName = path;
}
// test for attribute spec
if (nodeName.startsWith("@")) {
isAttribute = true;
}
Node singleNode;
try {
singleNode = getSingleNode(parent, nodeName);
} catch (TransformerException localException) {
throw new ProcessingException("XPathUtil.selectSingleNode: " + localException.getMessage(),
localException);
}
// create node if necessary
if (singleNode == null) {
Node newNode;
// delete XPath selectors
int posSelect = nodeName.indexOf("[");
String XPathExp = null;
if (posSelect != -1) {
XPathExp = nodeName.substring(posSelect + 1, nodeName.length() - 1);
nodeName = nodeName.substring(0, posSelect);
}
if (isAttribute) {
try {
newNode = getOwnerDocument(rootNode).createAttributeNS(null, nodeName.substring(1));
((Element) parent).setAttributeNodeNS((org.w3c.dom.Attr) newNode);
parent = newNode;
} catch (DOMException local) {
throw new ProcessingException("Unable to create new DOM node: '" + nodeName + "'.", local);
}
} else {
try {
newNode = getOwnerDocument(rootNode).createElementNS(null, nodeName);
} catch (DOMException local) {
throw new ProcessingException("Unable to create new DOM node: '" + nodeName + "'.", local);
}
if (XPathExp != null) {
java.util.List attrValuePairs = new java.util.ArrayList(4);
boolean noError = true;
String attr;
String value;
// scan for attributes
StringTokenizer tokenizer = new StringTokenizer(XPathExp, "= ");
while (tokenizer.hasMoreTokens()) {
attr = tokenizer.nextToken();
if (attr.startsWith("@")) {
if (tokenizer.hasMoreTokens()) {
value = tokenizer.nextToken();
if (value.startsWith("'") && value.endsWith("'"))
value = value.substring(1, value.length() - 1);
if (value.startsWith("\"") && value.endsWith("\""))
value = value.substring(1, value.length() - 1);
attrValuePairs.add(attr.substring(1));
attrValuePairs.add(value);
} else {
noError = false;
}
} else if (attr.trim().equals("and") == false) {
noError = false;
}
}
if (noError) {
for (int l = 0; l < attrValuePairs.size(); l = l + 2) {
((Element) newNode).setAttributeNS(null, (String) attrValuePairs.get(l),
(String) attrValuePairs.get(l + 1));
}
}
}
parent.appendChild(newNode);
parent = newNode;
}
} else {
parent = singleNode;
}
} while (pos != -1);
return parent;
}
/**
* Return the <CODE>Node</CODE> from the DOM Node <CODE>rootNode</CODE>
* using the XPath expression <CODE>path</CODE>. If the node does not
* exist, it is created and then returned. This is a very simple method for
* creating new nodes. If the XPath contains selectors ([,,,]) or "*" it is
* of course not possible to create the new node. So if you use such XPaths
* the node must exist beforehand. An simple exception is if the expression
* contains attribute test to values (e.g. [@id = 'du' and
*
* @number = 'you'], the attributes with the given values are added. The
* attributes must be separated with 'and'. Another problem are
* namespaces: XPath requires sometimes selectors for namespaces,
* e.g. : /*[namespace-uri()="uri" and local-name()="name"] Creating
* such a node with a namespace is not possible right now as we use
* a very simple XPath parser which is not able to parse all kinds
* of selectors correctly.
*
* @param rootNode
* The node to start the search.
* @param path
* XPath expression for searching the node.
* @param processor
* The XPath processor to use
* @return The node specified by the path.
* @throws ProcessingException
* If no path is specified or the XPath engine fails.
*/
public static Node selectSingleNode(Node rootNode, String path, XPathProcessor processor)
throws ProcessingException {
// Now we have to parse the string
// First test: path? rootNode?
if (path == null) {
throw new ProcessingException(XPATH_IS_REQUIRED);
}
if (rootNode == null)
return rootNode;
if (path.length() == 0 || path.equals("/"))
return rootNode;
// now the first "quick" test is if the node exists using the
// full XPathAPI
try {
Node testNode = getSingleNode(rootNode, path, processor);
if (testNode != null)
return testNode;
} catch (TransformerException local) {
throw new ProcessingException("Transforming exception during selectSingleNode with path: '" + path
+ "'. Exception: " + local, local);
}
// remove leading "/" oon both ends
path = StringUtils.strip(path, "/");
// now step through the nodes!
Node parent = rootNode;
int pos;
int posSelector;
do {
pos = path.indexOf("/"); // get next separator
posSelector = path.indexOf("[");
if (posSelector != -1 && posSelector < pos) {
posSelector = path.indexOf("]");
pos = path.indexOf("/", posSelector);
}
String nodeName;
boolean isAttribute = false;
if (pos != -1) { // found separator
nodeName = path.substring(0, pos); // string until "/"
path = path.substring(pos + 1); // rest of string after "/"
} else {
nodeName = path;
}
// test for attribute spec
if (nodeName.startsWith("@")) {
isAttribute = true;
}
Node singleNode;
try {
singleNode = getSingleNode(parent, nodeName, processor);
} catch (TransformerException localException) {
throw new ProcessingException("XPathUtil.selectSingleNode: " + localException.getMessage(),
localException);
}
// create node if necessary
if (singleNode == null) {
Node newNode;
// delete XPath selectors
int posSelect = nodeName.indexOf("[");
String XPathExp = null;
if (posSelect != -1) {
XPathExp = nodeName.substring(posSelect + 1, nodeName.length() - 1);
nodeName = nodeName.substring(0, posSelect);
}
if (isAttribute) {
try {
newNode = getOwnerDocument(rootNode).createAttributeNS(null, nodeName.substring(1));
((Element) parent).setAttributeNodeNS((org.w3c.dom.Attr) newNode);
parent = newNode;
} catch (DOMException local) {
throw new ProcessingException("Unable to create new DOM node: '" + nodeName + "'.", local);
}
} else {
try {
newNode = getOwnerDocument(rootNode).createElementNS(null, nodeName);
} catch (DOMException local) {
throw new ProcessingException("Unable to create new DOM node: '" + nodeName + "'.", local);
}
if (XPathExp != null) {
java.util.List attrValuePairs = new java.util.ArrayList(4);
boolean noError = true;
String attr;
String value;
// scan for attributes
StringTokenizer tokenizer = new StringTokenizer(XPathExp, "= ");
while (tokenizer.hasMoreTokens()) {
attr = tokenizer.nextToken();
if (attr.startsWith("@")) {
if (tokenizer.hasMoreTokens()) {
value = tokenizer.nextToken();
if (value.startsWith("'") && value.endsWith("'"))
value = value.substring(1, value.length() - 1);
if (value.startsWith("\"") && value.endsWith("\""))
value = value.substring(1, value.length() - 1);
attrValuePairs.add(attr.substring(1));
attrValuePairs.add(value);
} else {
noError = false;
}
} else if (attr.trim().equals("and") == false) {
noError = false;
}
}
if (noError) {
for (int l = 0; l < attrValuePairs.size(); l = l + 2) {
((Element) newNode).setAttributeNS(null, (String) attrValuePairs.get(l),
(String) attrValuePairs.get(l + 1));
}
}
}
parent.appendChild(newNode);
parent = newNode;
}
} else {
parent = singleNode;
}
} while (pos != -1);
return parent;
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node does not exist <CODE>null</CODE> is
* returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @return The value of the node or <CODE>null</CODE>
* @deprecated To be removed in 2.2.
*/
public static String getValueOf(Node root, String path) throws ProcessingException {
if (path == null) {
throw new ProcessingException(XPATH_IS_REQUIRED);
}
if (root == null)
return null;
path = StringUtils.strip(path, "/");
try {
Node node = getSingleNode(root, path);
if (node != null) {
return getValueOfNode(node);
}
} catch (TransformerException localException) {
throw new ProcessingException("XPathUtil.selectSingleNode: " + localException.getMessage(), localException);
}
return null;
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node does not exist <CODE>null</CODE> is
* returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param processor
* The XPath processor to use
* @return The value of the node or <CODE>null</CODE>
*/
public static String getValueOf(Node root, String path, XPathProcessor processor) throws ProcessingException {
if (path == null) {
throw new ProcessingException(XPATH_IS_REQUIRED);
}
if (root == null)
return null;
path = StringUtils.strip(path, "/");
try {
Node node = getSingleNode(root, path, processor);
if (node != null) {
return getValueOfNode(node);
}
} catch (TransformerException localException) {
throw new ProcessingException("XPathUtil.selectSingleNode: " + localException.getMessage(), localException);
}
return null;
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node is not found the <CODE>defaultValue</CODE>
* is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* The default value if the node does not exist.
* @return The value of the node or <CODE>defaultValue</CODE>
* @deprecated To be removed in 2.2.
*/
public static String getValueOf(Node root, String path, String defaultValue) throws ProcessingException {
String value = getValueOf(root, path);
if (value == null) {
value = defaultValue;
}
return value;
}
/**
* Get the value of the node specified by the XPath. This works similar to
* <xsl:value-of>. If the node is not found the <CODE>defaultValue</CODE>
* is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* The default value if the node does not exist.
* @param processor
* The XPath Processor
* @return The value of the node or <CODE>defaultValue</CODE>
*/
public static String getValueOf(Node root, String path, String defaultValue, XPathProcessor processor)
throws ProcessingException {
String value = getValueOf(root, path, processor);
if (value == null) {
value = defaultValue;
}
return value;
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @return The boolean value of the node.
* @throws ProcessingException
* If the node is not found.
* @deprecated To be removed in 2.2.
*/
public static boolean getValueAsBooleanOf(Node root, String path) throws ProcessingException {
String value = getValueOf(root, path);
if (value != null) {
return Boolean.valueOf(value).booleanValue();
} else {
throw new ProcessingException("No such node: " + path);
}
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param processor
* The XPath Processor
* @return The boolean value of the node.
* @throws ProcessingException
* If the node is not found.
*/
public static boolean getValueAsBooleanOf(Node root, String path, XPathProcessor processor)
throws ProcessingException {
String value = getValueOf(root, path, processor);
if (value == null) {
throw new ProcessingException("No such node: " + path);
}
return Boolean.valueOf(value).booleanValue();
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values. If the node does not exist,
* the <CODE>defaultValue</CODE> is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* Default boolean value.
* @return The value of the node or <CODE>defaultValue</CODE>
* @deprecated To be removed in 2.2.
*/
public static boolean getValueAsBooleanOf(Node root, String path, boolean defaultValue) throws ProcessingException {
String value = getValueOf(root, path);
if (value != null) {
return Boolean.valueOf(value).booleanValue();
}
return defaultValue;
}
/**
* Get the boolean value of the node specified by the XPath. This works
* similar to <xsl:value-of>. If the node exists and has a value this
* value is converted to a boolean, e.g. "true" or "false" as value will
* result into the corresponding boolean values. If the node does not exist,
* the <CODE>defaultValue</CODE> is returned.
*
* @param root
* The node to start the search.
* @param path
* XPath search expression.
* @param defaultValue
* Default boolean value.
* @param processor
* The XPath Processor
* @return The value of the node or <CODE>defaultValue</CODE>
*/
public static boolean getValueAsBooleanOf(Node root, String path, boolean defaultValue, XPathProcessor processor)
throws ProcessingException {
String value = getValueOf(root, path, processor);
if (value != null) {
return Boolean.valueOf(value).booleanValue();
}
return defaultValue;
}
/**
* Create a new empty DOM document.
*/
public static Document createDocument() throws ProcessingException {
try {
DocumentBuilderFactory documentFactory = DocumentBuilderFactory.newInstance();
documentFactory.setNamespaceAware(true);
documentFactory.setValidating(false);
DocumentBuilder docBuilder = documentFactory.newDocumentBuilder();
return docBuilder.newDocument();
} catch (ParserConfigurationException pce) {
throw new ProcessingException("Creating document failed.", pce);
}
}
/**
* Use an XPath string to select a nodelist. XPath namespace prefixes are
* resolved from the contextNode.
*
* @param contextNode
* The node to start searching from.
* @param str
* A valid XPath string.
* @return A NodeIterator, should never be null.
*
* @throws TransformerException
* @deprecated To be removed in 2.2.
*/
public static NodeList selectNodeList(Node contextNode, String str) throws TransformerException {
String[] pathComponents = buildPathArray(str);
if (pathComponents != null) {
return getNodeListFromPath(contextNode, pathComponents);
}
return XPathAPI.selectNodeList(contextNode, str);
}
/**
* Use an XPath string to select a nodelist. XPath namespace prefixes are
* resolved from the contextNode.
*
* @param contextNode
* The node to start searching from.
* @param str
* A valid XPath string.
* @param processor
* The XPath Processor
* @return A NodeIterator, should never be null.
*
* @throws TransformerException
*/
public static NodeList selectNodeList(Node contextNode, String str, XPathProcessor processor)
throws TransformerException {
String[] pathComponents = buildPathArray(str);
if (pathComponents != null) {
return getNodeListFromPath(contextNode, pathComponents);
}
return processor.selectNodeList(contextNode, str);
}
/**
* Build the input for the get...FromPath methods. If the XPath expression
* cannot be handled by the methods, <code>null</code> is returned.
*/
public static String[] buildPathArray(String xpath) {
String[] result = null;
if (xpath != null && xpath.charAt(0) != '/') {
// test
int components = 1;
int i, l;
l = xpath.length();
boolean found = false;
i = 0;
while (i < l && found == false) {
switch (xpath.charAt(i)) {
case '[':
found = true;
break;
case '(':
found = true;
break;
case '*':
found = true;
break;
case '@':
found = true;
break;
case ':':
found = true;
break;
case '/':
components++;
default:
i++;
}
}
if (found == false) {
result = new String[components];
if (components == 1) {
result[components - 1] = xpath;
} else {
i = 0;
int start = 0;
components = 0;
while (i < l) {
if (xpath.charAt(i) == '/') {
result[components] = xpath.substring(start, i);
start = i + 1;
components++;
}
i++;
}
result[components] = xpath.substring(start);
}
}
}
return result;
}
/**
* Use a path to select the first occurence of a node. The namespace of a
* node is ignored!
*
* @param contextNode
* The node starting the search.
* @param path
* The path to search the node. The contextNode is searched for a
* child named path[0], this node is searched for a child named
* path[1]...
* @param create
* If a child with the corresponding name is not found and create
* is set, this node will be created.
*/
public static Node getFirstNodeFromPath(Node contextNode, final String[] path, final boolean create) {
if (contextNode == null || path == null || path.length == 0)
return contextNode;
// first test if the node exists
Node item = getFirstNodeFromPath(contextNode, path, 0);
if (item == null && create) {
int i = 0;
NodeList childs;
boolean found;
int m, l;
while (contextNode != null && i < path.length) {
childs = contextNode.getChildNodes();
found = false;
if (childs != null) {
m = 0;
l = childs.getLength();
while (found == false && m < l) {
item = childs.item(m);
if (item.getNodeType() == Node.ELEMENT_NODE && item.getLocalName().equals(path[i])) {
found = true;
contextNode = item;
}
m++;
}
}
if (found == false) {
Element e = contextNode.getOwnerDocument().createElementNS(null, path[i]);
contextNode.appendChild(e);
contextNode = e;
}
i++;
}
item = contextNode;
}
return item;
}
/**
* Private helper method for getFirstNodeFromPath()
*/
private static Node getFirstNodeFromPath(final Node contextNode, final String[] path, final int startIndex) {
int i = 0;
NodeList childs;
boolean found;
int l;
Node item = null;
childs = contextNode.getChildNodes();
found = false;
if (childs != null) {
i = 0;
l = childs.getLength();
while (found == false && i < l) {
item = childs.item(i);
if (item.getNodeType() == Node.ELEMENT_NODE
&& path[startIndex].equals(item.getLocalName() != null ? item.getLocalName() : item
.getNodeName())) {
if (startIndex == path.length - 1) {
found = true;
} else {
item = getFirstNodeFromPath(item, path, startIndex + 1);
if (item != null)
found = true;
}
}
if (found == false) {
i++;
}
}
if (found == false) {
item = null;
}
}
return item;
}
/**
* Use a path to select all occurences of a node. The namespace of a node is
* ignored!
*
* @param contextNode
* The node starting the search.
* @param path
* The path to search the node. The contextNode is searched for a
* child named path[0], this node is searched for a child named
* path[1]...
*/
public static NodeList getNodeListFromPath(Node contextNode, String[] path) {
if (contextNode == null)
return new NodeListImpl();
if (path == null || path.length == 0) {
return new NodeListImpl(new Node[] { contextNode });
}
NodeListImpl result = new NodeListImpl();
try {
getNodesFromPath(result, contextNode, path, 0);
} catch (NullPointerException npe) {
// this NPE is thrown because the parser is not configured
// to use DOM Level 2
throw new NullPointerException("XMLUtil.getNodeListFromPath() did catch a NullPointerException."
+ "This might be due to a missconfigured XML parser which does not use DOM Level 2."
+ "Make sure that you use the XML parser shipped with Cocoon.");
}
return result;
}
/**
* Helper method for getNodeListFromPath()
*/
private static void getNodesFromPath(final NodeListImpl result, final Node contextNode, final String[] path,
final int startIndex) {
final NodeList childs = contextNode.getChildNodes();
int m, l;
Node item;
if (startIndex == (path.length - 1)) {
if (childs != null) {
m = 0;
l = childs.getLength();
while (m < l) {
item = childs.item(m);
if (item.getNodeType() == Node.ELEMENT_NODE) {
// Work around: org.apache.xerces.dom.ElementImpl
// doesn't handle getLocalName() correct
if (path[startIndex].equals(item.getLocalName() != null ? item.getLocalName() : item
.getNodeName())) {
result.addNode(item);
}
}
m++;
}
}
} else {
if (childs != null) {
m = 0;
l = childs.getLength();
while (m < l) {
item = childs.item(m);
if (item.getNodeType() == Node.ELEMENT_NODE) {
// Work around: org.apache.xerces.dom.ElementImpl
// doesn't handle getLocalName() correct
if (path[startIndex].equals(item.getLocalName() != null ? item.getLocalName() : item
.getNodeName())) {
getNodesFromPath(result, item, path, startIndex + 1);
}
}
m++;
}
}
}
}
/**
* Converts a org.w3c.dom.Node to a String. Uses
* {@link javax.xml.transform.Transformer} to convert from a Node to a
* String.
*
* @param node
* a <code>org.w3c.dom.Node</code> value
* @return String representation of the document
* @deprecated Use {@link XMLUtils#serializeNodeToXML(Node)} instead. To be
* removed in 2.2.
*/
public static String node2String(Node node) {
try {
return XMLUtils.serializeNodeToXML(node);
} catch (ProcessingException e) {
// Empty
}
return "";
}
/**
* Create a string representation of a org.w3c.dom.Node and any (most)
* subtypes.
*
* @param node
* a <code>org.w3c.dom.Node</code> value
* @param pretty
* a <code>boolean</code> value whether to format the XML
* @return a <code>String</code> value
* @deprecated Please use {@link XMLUtils#serializeNode(Node, Properties)}
* instead. To be removed in 2.2.
*/
public static String node2String(Node node, boolean pretty) {
try {
if (pretty) {
Properties props = new Properties();
props.setProperty(OutputKeys.INDENT, "yes");
return XMLUtils.serializeNode(node, props);
} else {
return XMLUtils.serializeNodeToXML(node);
}
} catch (ProcessingException e) {
}
return "";
}
/**
* Create a string representation of a org.w3c.dom.Node and any (most)
* subtypes.
*
* @param node
* a <code>org.w3c.dom.Node</code> value
* @return a <code>StringBuffer</code> value
* @deprecated Please use {@link XMLUtils#serializeNodeToXML(Node)} instead.
* To be removed in 2.2.
*/
public static StringBuffer node2StringBuffer(Node node) {
return new StringBuffer(node2String(node));
}
/**
* Create a string representation of a org.w3c.dom.Node and any (most)
* subtypes.
*
* @param node
* a <code>org.w3c.dom.Node</code> value
* @param pretty
* a <code>boolean</code> value whether to format the XML
* @param indent
* a <code>String</code> value containing spaces as initial
* indent, if null defaults to empty string.
* @return a <code>StringBuffer</code> value
* @deprecated Please use {@link XMLUtils#serializeNode(Node, Properties)}
* instead. To be removed in 2.2.
*/
public static StringBuffer node2StringBuffer(Node node, boolean pretty, String indent) {
return new StringBuffer(node2String(node, pretty));
}
}