DOMUtils.java

Violations

Source code

/*
  * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */

package biz.hammurapi.xml.dom;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
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 biz.hammurapi.config.ConfigurationException;
import biz.hammurapi.convert.ConvertingService;

/**
 * Utility class for querying DOM.
 *
 * @author Pavel Vlasov
 */
public class DOMUtils {

	/** Creates a new instance of DOMUtils */
	private DOMUtils() {
		// Utility class

	}

	/**
	 * Ensures that thre is one and only one element and returns it.
	 * @throws XPathExpressionException
	 */
	public static Element getSingleElement(Element e, String elementName) throws ConfigurationException, XPathExpressionException {
		NodeList nl = selectNodeList(e, elementName);
		if (nl.getLength() == 0) {
			throw new ConfigurationException("Element <" + elementName
					+ "> not found");
		}
		if (nl.getLength() > 1) {
			throw new ConfigurationException("Duplicate element <"
					+ elementName + ">");
		}

		return (Element) nl.item(0);
	}

	/**
	 * Ensures that there is only one element and returns its text
	 * @throws TransformerException
	 * @throws XPathExpressionException
	 * @throws TransformerException
	 */
	public static String getSingleElementText(Element e, String elementName) throws ConfigurationException, XPathExpressionException {
		return getElementText(getSingleElement(e, elementName));
	}

	public static String getSingleNonBlankElementText(Element e, String elementName) throws ConfigurationException,	XPathExpressionException {
		return getNonBlankElementText(getSingleElement(e, elementName));
	}

	public static String getElementText(Element e) throws XPathExpressionException {
		return String.valueOf(eval(e, "text()"));
	}

	public static String getNonBlankElementText(Element e) throws ConfigurationException, XPathExpressionException {
		String res = getElementText(e);
		if (res.trim().length() == 0) {
			throw new ConfigurationException("Element <" + e.getNodeName() + "> is blank");
		}
		return res;
	}

	public static Properties dom2Properties(Element e, String prefix) throws XPathExpressionException {
		String root = prefix == null ? e.getNodeName() : prefix + "."
				+ e.getNodeName();
		Properties res = new Properties();
		String text = getElementText(e);
		if (text.trim().length() != 0) {
			res.setProperty(root, text);
		}

		NamedNodeMap attributes = e.getAttributes();
		for (int i=0, l=attributes.getLength(); i<l; i++) {
			Node attribute=attributes.item(i);
			res.setProperty(root+"("+attribute.getNodeName()+")", attribute.getNodeValue());
		}
		
		
		NodeList nl = e.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node n = nl.item(i);
			if (n.getNodeType() == Node.ELEMENT_NODE) {
				res.putAll(dom2Properties((Element) n, root));
			}
		}

		return res;
	}

	/**
	 * Reads elements &lt;property name="..."&gt;...&lt/property&gt; into
	 * properties
	 * @throws XPathExpressionException
	 */
	public static void readProperties(Element holder, Properties properties) throws ConfigurationException, XPathExpressionException {
		NodeList nl = selectNodeList(holder, "property");
		for (int i=0, l=nl.getLength(); i<l; ++i) {
			Element el = (Element) nl.item(i);
			if (!el.hasAttribute("name")) {
				throw new ConfigurationException("Unnamed property");
			}
			if (properties.containsKey(el.getAttribute("name"))) {
				throw new ConfigurationException("Property already set: "
						+ el.getAttribute("name"));
			}

			properties.setProperty(el.getAttribute("name"), DOMUtils.getNonBlankElementText(el));
		}
	}
	
	public static void serialize(Object o, String root, Result result) throws ParserConfigurationException, FactoryConfigurationError, TransformerException {
	    Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
	    Element rootElement = AbstractDomObject.addElement(doc, root);
	    toDom(o, rootElement);
        TransformerFactory
			.newInstance()
			.newTransformer()
			.transform(new DOMSource(doc), result);
	}

	public static void serialize(Object o, String root, File out) throws ParserConfigurationException, FactoryConfigurationError, IOException, TransformerException {
	    Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
	    Element rootElement = AbstractDomObject.addElement(doc, root);
	    toDom(o, rootElement);
		FileOutputStream os = new FileOutputStream(out);
		serialize(doc, os);
		os.close();
	}
	
	public static void serialize(Node node, File out) throws IOException, TransformerException {
		FileOutputStream os = new FileOutputStream(out);
		serialize(node, os);
		os.close();
	}

	public static void serialize(Node node, OutputStream os) throws TransformerException {
        TransformerFactory
			.newInstance()
			.newTransformer()
			.transform(new DOMSource(node), new StreamResult(os));
	}
	
	public static void serialize(Node node, Writer w) throws TransformerException {
        TransformerFactory
			.newInstance()
			.newTransformer()
			.transform(new DOMSource(node), new StreamResult(w));
	}
	
	public static String toString(Node node) throws IOException, TransformerException {
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        
        //transformer.setOutputProperty("method", "xml");

        transformer.setOutputProperty("indent", "yes");
        transformer.setOutputProperty("omit-xml-declaration", "yes");
        
        StringWriter sw=new StringWriter();
		transformer.transform(new DOMSource(node), new StreamResult(sw));
		sw.close();
		return sw.toString();
	}	
	
	public static String toXmlString(Object o, String root) throws IOException, TransformerException, ParserConfigurationException, FactoryConfigurationError {
	    Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
	    Element rootElement = AbstractDomObject.addElement(doc, root);
	    toDom(o, rootElement);
	    return toString(rootElement);
	}
		
	public static void style(Object o, String root, OutputStream os, InputStream style, Map parameters) throws ParserConfigurationException, FactoryConfigurationError, TransformerException {
	    Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
	    Element rootElement = AbstractDomObject.addElement(doc, root);
	    toDom(o, rootElement);
	    style(doc, os, style, parameters);
	}

	public static void style(Object o, String root, File out, InputStream style, Map parameters) throws ParserConfigurationException, FactoryConfigurationError, IOException, TransformerException {
	    Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
	    Element rootElement = AbstractDomObject.addElement(doc, root);
	    toDom(o, rootElement);
		FileOutputStream os = new FileOutputStream(out);
		style(doc, os, style, parameters);
		os.close();
	}
	
	public static void style(Document doc, File out, InputStream style, Map parameters) throws IOException, TransformerException {
		FileOutputStream os = new FileOutputStream(out);
		style(doc, os, style, parameters);
		os.close();
	}

	public static void style(Document doc, OutputStream os, InputStream style, Map parameters) throws TransformerException {
	    TransformerFactory factory=TransformerFactory.newInstance();
	    Transformer transformer = style==null ? factory.newTransformer() : factory.newTransformer(new StreamSource(style));
	    if (parameters!=null) {
	        Iterator it=parameters.entrySet().iterator();
	        while (it.hasNext()) {
	            Map.Entry entry=(Map.Entry) it.next();
	            transformer.setParameter((String) entry.getKey(), entry.getValue());
	        }
	    }
	    transformer.transform(new DOMSource(doc), new StreamResult(os));
	}
	
	public static Document parse(File file) throws SAXException, IOException, ParserConfigurationException, FactoryConfigurationError {
		InputStream is=new FileInputStream(file);
		try {
			return parse(is);
		} finally {
			is.close();
		}
	}

	/**
	 * @param is
	 * @return
	 * @throws FactoryConfigurationError
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static Document parse(InputStream is) throws SAXException, IOException, ParserConfigurationException, FactoryConfigurationError {
		return DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(is);
	}
	
	/**
	 * @param is
	 * @return
	 * @throws FactoryConfigurationError
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static Document parse(Reader is) throws SAXException, IOException, ParserConfigurationException, FactoryConfigurationError {
		return DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(is));
	}
	
	/**
	 * Serializes object to XML. Specially treats collections,
	 * maps, arrays and DomSerializable objects.
	 * @param o
	 * @param holder
	 */
	public static void toDom(Object o, Element holder) {
		if (o!=null) {
			DomSerializable ds = (DomSerializable) ConvertingService.convert(o, DomSerializable.class);
			if (ds!=null) {
				ds.toDom(holder);
			}
		}
	}		
	
	/**
	 * Serializes object to XML. Specially treats collections,
	 * maps, arrays and DomSerializable objects.
	 * @param o
	 * @param name Element name
	 * @param parent parent element
	 */
	public static void toDom(Object o, String name, Element parent) {
		if (o!=null) {
			DomSerializable ds = (DomSerializable) ConvertingService.convert(o, DomSerializable.class);
			if (ds!=null) {
				Element holder=parent.getOwnerDocument().createElement(name);
				parent.appendChild(holder);
				ds.toDom(holder);
			}
		}
	}
	
	public static Document toDom(Object o) throws ParserConfigurationException, FactoryConfigurationError {
		Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
		Element root=document.createElement("root");
		document.appendChild(root);
		toDom(o, root);
		return document;		
	}

	public static String eval(Object item, String str) throws XPathExpressionException {
		return getXPath().evaluate(str, item);
	}

	public static Object eval(Object item, String str, QName returnType) throws XPathExpressionException {
		return getXPath().evaluate(str, item, returnType);
	}

	private static XPath getXPath() {
		XPathFactory xPathFactory = XPathFactory.newInstance();		
		XPath xpath = xPathFactory.newXPath();
		return xpath;
	}

	public static NodeList selectNodeList(Node contextNode, String str) throws XPathExpressionException {
		return (NodeList) eval(contextNode, str, XPathConstants.NODESET);
	}

	public static Node selectSingleNode(Node contextNode, String str) throws XPathExpressionException {
		NodeList nl = selectNodeList(contextNode, str);
		return nl.getLength()==0 ? null : nl.item(0);
	}
	
}