/*
    *  Copyright (C) 2003-2005 SINTEF
    *  Author:  Fredrik Vraalsen (fredrik dot vraalsen at sintef dot no)
    *  Webpage: http://coras.sourceforge.net/
    *
    *  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.1
    *  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 program; if not, write to the Free
   *  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   *  02111-1307 USA
   */
  package no.sintef.xml;
  
  import java.io.BufferedOutputStream;
  import java.io.BufferedWriter;
  import java.io.ByteArrayOutputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.StringReader;
  import java.io.Writer;
  import java.lang.ref.SoftReference;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.ErrorListener;
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  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 org.apache.log4j.Logger;
  import org.apache.xalan.processor.TransformerFactoryImpl;
  import org.doomdark.uuid.UUIDGenerator;
  import org.w3c.dom.DOMImplementation;
  import org.w3c.dom.Document;
  import org.w3c.dom.DocumentType;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.w3c.dom.Text;
  import org.xml.sax.EntityResolver;
  import org.xml.sax.InputSource;
  import org.xml.sax.helpers.DefaultHandler;
  
  /***
   * XML helper class.
   * 
   * @author Fredrik Vraalsen
   */
  public final class XmlHelper {
  	
  	private static final Logger LOGGER = Logger.getLogger(XmlHelper.class);
  	
  	private static final DocumentCache DOCUMENT_CACHE = new DocumentCache();
  	private static final TransformerCache TRANSFORMER_CACHE = new TransformerCache(DOCUMENT_CACHE);
  	private static final DocumentBuilderFactory DBF;
  	private static final EntityResolver ER = new DefaultHandler() {
  		public InputSource resolveEntity(String publicId, String systemId) {
  			LOGGER.debug("publicId = " + publicId + ", systemId = " + systemId);
  			return new InputSource(new StringReader("")); // Disable external DTD resolving...
  		}
  	};
  
  	/***
  	 *  ThreadLocal identityTransformation to avoid reentrancy issues.
  	 */
  	private static ThreadLocal identityTransformation = new ThreadLocal() {
  		protected synchronized Object initialValue() {
  			try {
  				Transformer t = TransformerFactory.newInstance().newTransformer();
  				t.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
  				t.setOutputProperty(OutputKeys.INDENT, "yes");
  				return t;
  			} catch (TransformerConfigurationException e) {
 				e.printStackTrace();
 				return null;
 			}
 		}
 	};
 
 	static { 
 		DBF = DocumentBuilderFactory.newInstance();
 		DBF.setNamespaceAware(true);
 		DBF.setValidating(false);
 		// tf.setURIResolver(documentCache);
 	}
 	
 	/***
 	 * Prevent instantiation of helper class.
 	 */
 	private XmlHelper() {
 	}
 	
 	/***
 	 * Get document root element if Node is Document, otherwise cast node to
 	 * Element if appropriate.
 	 * 
 	 * TODO rename to getElement?
 	 * 
 	 * @param node
 	 *            node to get Element for
 	 * @return Element corresponding to node, or null if node is not Document or
 	 *         Element instance
 	 */
 	public static Element getRootElement(Node node) {
 		if (node instanceof Element) {
 			return (Element) node;
 		} else if (node instanceof Document) {
 			Document doc = (Document) node;
 			return doc.getDocumentElement();
 		} else {
 			return null;
 		}
 	}
 	
 	/***
 	 * Get first child Element matching the specified name and namespace.
 	 * 
 	 * @param parent
 	 *            parent Element
 	 * @param namespaceURI
 	 *            the URI of the namespace to match
 	 * @param localName
 	 *            the local name to match
 	 * @return the first child Element matching local name and namespace, or
 	 *         null if none exists
 	 */
 	public static Element getFirstElement(Element parent, String namespaceURI, String localName) {
 		List elements = getElements(parent, namespaceURI, localName);
 		if (elements.size() == 0) {
 			return null;
 		} else {
 			return (Element) elements.get(0);
 		}
 	}
 	
 	/***
 	 * Get child Elements matching the specified name and namespace.
 	 * 
 	 * @param parent
 	 *            parent Element
 	 * @param namespaceURI
 	 *            the URI of the namespace to match
 	 * @param localName
 	 *            the local name to match
 	 * @return List of matching child elements, possibly empty (never null)
 	 */
 	public static List getElements(Element parent, String namespaceURI, String localName) {
 		if (parent == null) {
 			return Collections.EMPTY_LIST;
 		}
 		
 		ArrayList result = new ArrayList();
 		NodeList nodes = parent.getChildNodes();
 		int length = nodes.getLength();
 		for (int i = 0; i < length; i++) {
 			Node n = nodes.item(i);
 			if (!(n instanceof Element)) {
 				continue;
 			}
 			Element e = (Element) n;
 			if (namespaceURI == null && localName != null && !localName.equals(e.getTagName())) {
 				continue;
 			} else if (namespaceURI != null && localName != null && !localName.equals(e.getLocalName())) {
 				continue;
 			} else if (namespaceURI != null && !namespaceURI.equals(e.getNamespaceURI())) {
 				continue;
 			}
 			result.add(e);
 		}
 		
 		return result;
 	}
 	
 	/***
 	 * Get text content of element.
 	 * 
 	 * @param element
 	 *            the element
 	 * @return the text content of element (possibly empty), or null if element
 	 *         is null
 	 */
 	public static String getText(Element element) {
 		if (element == null) {
 			return null;
 		}
 		StringBuffer sb = new StringBuffer();
 		NodeList children = element.getChildNodes();
 		for (int i = 0; i < children.getLength(); i++) {
 			Node n = children.item(i);
 			if (n instanceof Text) {
 				sb.append(n.getNodeValue());
 			} else if (n instanceof Element) {
 				sb.append(getText((Element) n));
 			}
 		}
 		return sb.toString();
 	}
 
 	/***
 	 * Get text content of first child element matching the specified name and
 	 * namespace.
 	 * 
 	 * @param parent
 	 *            parent element
 	 * @param namespaceURI
 	 *            the URI of the namespace to match
 	 * @param localName
 	 *            the local name to match
 	 * @return the text content of element, or null if no element matches or
 	 *         matching element is mixed or does not have text node child
 	 */
 	public static String getText(Element parent, String namespaceURI, String localName) {
 	    Element e = getFirstElement(parent, namespaceURI, localName);
 	    return getText(e);
 	}
 	
 	/***
 	 * Parse XML Document from InputSource.
 	 * 
 	 * @param is the InputSource to parse from.
 	 * @return resulting XML Document, never null 
 	 * @throws XmlException if XML document was malformed or other XML parsing error occured
 	 * @throws IOException if IO error occured reading from InputSource
 	 */
 	public static Document parse(InputSource is) throws XmlException, IOException {
 		Document result = null;
 		try {
 			DocumentBuilder db = DBF.newDocumentBuilder();
 			// Disable external DTD resolving...
 			db.setEntityResolver(ER); 
 			result = db.parse(is);
 		} catch (IOException e) {
 		    throw e;
 		} catch (Exception e) {
 			throw new XmlException("Unable to parse XML", e);
 		}
 		if (result == null) {
 			// TODO This should never happen!?
 			throw new XmlException("Null XML document"); 
 		}
 		return result;
 	}
 
 	/***
 	 * Generate unique identifier.
 	 * 
 	 * @return the unique identifier
 	 */
 	public static String genID() {
 		return "I" + UUIDGenerator.getInstance().generateTimeBasedUUID();
 	}
 	
 	/***
 	 * Create XML Document of the specified DocumentType and with a root Element
 	 * with the specified namespace, namespace prefix and name.
 	 * 
 	 * @param namespaceUri
 	 *            URI of namespace for root element
 	 * @param namespacePrefix
 	 *            prefix to use for root element namespace
 	 * @param rootElement
 	 *            local name of root element
 	 * @param doctype
 	 *            DocumentType of document
 	 * @return the XML Document, or null if error occurs
 	 */
 	public static Document createDocument(String namespaceUri, 
 			String namespacePrefix, String rootElement, DocumentType doctype) {
 		try {
 			DocumentBuilder db = DBF.newDocumentBuilder();
 			DOMImplementation di = db.getDOMImplementation();
 			String qName = namespacePrefix != null ? namespacePrefix + ":" + rootElement : rootElement;
 			Document doc = di.createDocument(namespaceUri, qName, doctype);
 			return doc;
 		} catch (ParserConfigurationException e) {
 			e.printStackTrace();
 			return null;
 		}
 	}
 
 	/***
 	 * Create XML Document with the specified root element.
 	 * 
 	 * @param elem
 	 *            the root element
 	 * @return the XML Document, or null if error occurs
 	 */
 	public static Document createDocument(Element elem) {
         try {
             DocumentBuilder db = DBF.newDocumentBuilder();
             Document doc = db.newDocument();
             if (elem != null) {
                 Node n = doc.importNode(elem, true);
                 doc.appendChild(n);
             }
             return doc;
         } catch (ParserConfigurationException e) {
             e.printStackTrace();
             return null;
         }
 	}
 	
 	/***
 	 * Get the XSLT transformation from the specified URL.
 	 * 
 	 * @param url
 	 *            URL to get the XSLT transformation from, or null to get identity (null) transformation
 	 * @param logger
 	 *            Logger to use for error messages
 	 * @return the Transformer, never null
 	 * @throws XmlException
 	 *             if error occurs
 	 */
 	public static Transformer getTransformer(URL url, final Logger logger) throws XmlException {
 		Transformer result = TRANSFORMER_CACHE.get(url);
 		// FIXME ensure that transformer is never null
 		if (result == null) {
 			throw new XmlException("THIS SHOULD NEVER HAPPEN: transformer is null");
 		}
 		if (logger != null) {
 			result.setErrorListener(new ErrorListener() {
 				public void warning(TransformerException e) throws TransformerException {
 					if (logger.isDebugEnabled()) {
 						logger.debug(e.getMessage());
 					}
 				}
 				public void error(TransformerException e) throws TransformerException {
 					logger.warn(e.getMessage(), e);
 				}
 				public void fatalError(TransformerException e) throws TransformerException {
 					logger.error(e.getMessage(), e);
 				}
 			});
 		}
 		return result;
 	}
 	
 	/***
 	 * Get the identity (null) transformation.
 	 * 
 	 * @return the identity (null) transformation
 	 */
 	public static Transformer getIdentityTransformation() {
 		return (Transformer) identityTransformation.get();
 	}
 
 	/***
 	 * Serialize XML node to byte array in UTF-8 format.
 	 * 
 	 * @param node
 	 *            the Node to serialize
 	 * @param outputHeader
 	 *            true if XML header should be added, false otherwise
 	 * @return byte array containing the UTF-8 bytes
 	 */
 	public static byte[] xmlToUtf8(Node node, boolean outputHeader) {
 	    ByteArrayOutputStream baos = new ByteArrayOutputStream();
 	    BufferedOutputStream bos = new BufferedOutputStream(baos);
 	    xmlToUtf8(node, bos, outputHeader);
 	    try {
 		    bos.close();
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	    return baos.toByteArray();
 	}
 
 	/***
 	 * Serialize XML node to specified output stream in UTF-8 format.
 	 * 
 	 * @param node
 	 *            the Node to serialize
 	 * @param os
 	 *            the OutputStream to serialize to
 	 * @param outputHeader
 	 *            true if XML header should be added, false otherwise
 	 */
 	public static void xmlToUtf8(Node node, OutputStream os, boolean outputHeader) {
 		try {
 			Transformer t = getIdentityTransformation();
 			t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, outputHeader ? "no" : "yes");
 			DOMSource source = new DOMSource(node);
 			Writer w = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
 			StreamResult result = new StreamResult(w);
 			t.transform(source, result);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 
 	/***
 	 * Get XML Document from the specified URL.
 	 * 
 	 * @param url
 	 *            URL to parse from
 	 * @return the XML Document
 	 * @throws XmlException
 	 *             if error occurs
 	 */
 	public static Document getDocument(URL url) throws XmlException {
 		return DOCUMENT_CACHE.get(url);
 	}
 	
 }
 
 
 
 /***
  * XML Document cache.
  * 
  * @author Fredrik Vraalsen
  */
 class DocumentCache implements javax.xml.transform.URIResolver {
 
 	private static final Logger LOGGER = Logger.getLogger(DocumentCache.class);
 	private HashMap documents = new HashMap();
 
 	/***
 	 * Cached get of the XML Document from the specified URL.
 	 * 
 	 * @param url
 	 *            the URL of the document
 	 * @return the Document, or null if document could not be retrieved from URL
 	 * @throws XmlException
 	 *             if error in parsing XML document
 	 */
 	public Document get(URL url) throws XmlException {
 		DocumentEntry entry = getEntry(url);
 		return entry != null ? entry.getDoc() : null;
 	}
 	
 	/***
 	 * Get cache entry for XML document with specified URL, retrieving document
 	 * if not in cache or not up to date.
 	 * 
 	 * @param url
 	 *            the URL of the document
 	 * @return the cache entry for the document, or null if document could not
 	 *         be retrieved from URL
 	 * @throws XmlException
 	 *             if error in parsing XML document
 	 */
 	private DocumentEntry getEntry(URL url) throws XmlException {
 		if (url == null) {
 			return null;
 		}
 		String urlString = url.toString();
 		long lastModified = 0;
 		URLConnection conn = null;
 		try {
 			conn = url.openConnection();
 			lastModified = conn.getLastModified();
 		} catch (IOException e) {
 			// do nothing;
 			if (LOGGER.isDebugEnabled()) {
 				LOGGER.debug("IOException when loading document: " + urlString);
 			}
 		}
 		LOGGER.debug("last modified: " + lastModified);
 		DocumentEntry result = getEntry(urlString, lastModified);
 		if (result != null) {
 			return result;
 		}
 		if (conn != null) {
 			synchronized (this) {
 				try {
 					Document doc = XmlHelper.parse(new InputSource(conn.getInputStream()));
 					return setEntry(urlString, lastModified, doc);
 				} catch (IOException e) {
 					throw new XmlException("Unable to read XML: " + url, e);
 				}
 			}
 		} else {
 			return null;
 		}
 	}
 	
 	/***
 	 * Get cache entry for XML document with specified URL if up to date,
 	 * otherwise remove entry from cache.
 	 * 
 	 * @param url
 	 *            the URL of the document
 	 * @param lastModified
 	 *            last modification time of document
 	 * @return the cache entry for the document, or null if document is not up
 	 *         to date
 	 */
 	private DocumentEntry getEntry(String url, long lastModified) {
 		SoftReference ref = (SoftReference) documents.get(url);
 		if (ref == null) {
 			LOGGER.debug("Document cache MISS: " + url);
 			return null;
 		}
 		Object o = ref.get();
 		if (!(o instanceof DocumentEntry)) {
 			LOGGER.debug("Document cache MISS: " + url);
 			return null;
 		}
 		DocumentEntry entry = (DocumentEntry) o;
 		if (lastModified <= entry.getLastModified()) {
 			LOGGER.debug("Document cache HIT: " + url);
 			return entry;
 		} else {
 			LOGGER.debug("Document cache MISS (outdated): " + url);
 			documents.remove(url);
 			return null;
 		}
 	}
 	
 	/***
 	 * Set cache entry for XML document.
 	 * 
 	 * @param url
 	 *            URL of document
 	 * @param lastModified
 	 *            last modification time of document
 	 * @param doc
 	 *            the XML document
 	 * @return the cache entry
 	 */
 	private synchronized DocumentEntry setEntry(String url, long lastModified, Document doc) {
 		if (doc != null) { 
 			DocumentEntry entry = new DocumentEntry(doc, lastModified);
 			SoftReference ref = new SoftReference(entry);
 			documents.put(url, ref);
 			return entry;
 		} else {
 			documents.remove(url);
 			return null;
 		}
 	}
 	
 	/***
 	 * Resolve the XML document at the specified URI (base + href) into an XML
 	 * Source object.
 	 * 
 	 * @param href
 	 *            relative URI
 	 * @param base
 	 *            base URI
 	 * @return the Source object, or null if the document cannot be resolved
 	 * @see javax.xml.transform.URIResolver#resolve(java.lang.String,
 	 *      java.lang.String)
 	 */
 	public Source resolve(String href, String base) {
 		LOGGER.debug("resolve(" + href + ", " + base + ")");
 		URL url = null;
 		if (base != null) {
 		    try {
 		        URL baseUrl = new URL(base);
 		        url = new URL(baseUrl, href);
 		    } catch (MalformedURLException e1) {
 		        // TODO Auto-generated catch block
 		        e1.printStackTrace();
 		    }
 		}
 		if (url == null) {
 		    ClassLoader cl = getClass().getClassLoader();
 		    url = cl.getResource(href);
 		    if (url == null) {
 				url = cl.getResource("coras/uml/" + href);
 			}
 		}
 		LOGGER.debug("url = " + url);
 		try {
 			DocumentEntry entry = getEntry(url);
 			return entry != null ? entry.getSource() : null;
 		} catch (XmlException e) {
 			return null;
 		}
 	}
 }
 
 /***
  * XML document cache entry.
  * 
  * @author Fredrik Vraalsen
  */
 final class DocumentEntry {
 	
 	private Document doc;
 	private long lastModified;
 	private Source source;
 	
 	/***
 	 * @param doc
 	 *            the XML document
 	 * @param lastModified
 	 *            last modification time of document
 	 */
 	protected DocumentEntry(Document doc, long lastModified) {
 		this.doc = doc;
 		this.lastModified = lastModified;
 	}
 	
 	/***
 	 * @return the XML document
 	 */
 	public Document getDoc() {
 		return doc;
 	}
 	
 	/***
 	 * @return the last modification time of the document
 	 */
 	public long getLastModified() {
 		return lastModified;
 	}
 	
 	/***
 	 * @return the document as a Source object
 	 */
 	public Source getSource() {
 		if (source == null) {
 			source = new DOMSource(doc);
 		}
 		return source;
 	}
 	
 }
 
 
 /***
  * XSLT Transformer cache implemented on top of DocumentCache.
  *  
  * @author Fredrik Vraalsen
  */
 class TransformerCache {
 	
 	private static final Logger LOGGER = Logger.getLogger(TransformerCache.class);
 	private static final TransformerFactory TF = new TransformerFactoryImpl(); 
 	private HashMap transformations = new HashMap();
 
 	/***
 	 * @param documentCache the document cache used to cache XSLT documents
 	 */
 	protected TransformerCache(final DocumentCache documentCache) {
 		if (documentCache != null) {
 			final javax.xml.transform.URIResolver defaultResolver = TF.getURIResolver();
 			TF.setURIResolver(new javax.xml.transform.URIResolver() {
 				public Source resolve(String href, String base) throws TransformerException {
 					Source source = documentCache.resolve(href, base);
 					if (source == null) {
 						source = defaultResolver.resolve(href, base);
 					}
 					return source;
 				}
 				
 			});
 		}
 	}
 	
 	/***
 	 * Cached get of the XSLT transformer from the specified URL.
 	 * 
 	 * @param url
 	 *            the URL of the XSLT transformation
 	 * @return the XSLT Transformer, or null if an error occurs
 	 * @throws XmlException
 	 *             if error parsing XSTL transformation
 	 */
 	public Transformer get(URL url) throws XmlException {
 		String urlString = url != null ? url.toString() : null;
 		LOGGER.debug("URL: " + urlString);
 		long lastModified = 0;
 		URLConnection conn = null;
 		if (url != null) {
 			try {
 				conn = url.openConnection();
 				lastModified = conn.getLastModified();
 			} catch (IOException e) {
 				// do nothing
 				if (LOGGER.isDebugEnabled()) {
 					LOGGER.debug("IOException when getting transformer: " + urlString);
 				}
 			}
 		}
 		LOGGER.debug("last modified: " + lastModified);
 		TransformerEntry entry = getEntry(urlString, lastModified);
 		Transformer result = entry != null ? entry.getTransformer() : null;
 		if (result == null) {
 			synchronized (this) {
 				try {
 					result = createTransformer(conn != null ? conn.getInputStream() : null, url);
 				} catch (IOException e) {
 					throw new XmlException("Unable to read XSLT: " + url, e);
 				}
 				setEntry(urlString, lastModified, result);
 			}
 		}
 		return result;
 	}
 
 	/***
 	 * Get the cache entry for the XSLT transformer.
 	 * 
 	 * @param url
 	 *            the URL of the XSLT transformation
 	 * @param lastModified
 	 *            the last modification time of the XSLT transformation
 	 * @return the cache entry for the transformer, or null if transformer is
 	 *         not up to date
 	 */
 	private TransformerEntry getEntry(String url, long lastModified) {
 		SoftReference ref = (SoftReference) transformations.get(url);
 		if (ref == null) {
 			LOGGER.debug("Transformer cache MISS: " + url);
 			return null;
 		}
 		Object o = ref.get();
 		if (!(o instanceof TransformerEntry)) {
 			LOGGER.debug("Transformer cache MISS: " + url);
 			return null;
 		}
 		TransformerEntry entry = (TransformerEntry) o;
 		if (lastModified <= entry.getLastModified()) {
 			LOGGER.debug("Transformer cache HIT: " + url);
 			return entry;
 		} else {
 			LOGGER.debug("Transformer cache MISS (outdated): " + url);
 			transformations.remove(url);
 			return null;
 		}
 	}
 	
 	/***
 	 * Set the cache entry for the XSLT transformer.
 	 * 
 	 * @param url
 	 *            URL of the XSLT transformation
 	 * @param lastModified
 	 *            last modification time of XSLT transformation
 	 * @param transformer
 	 *            the XSLT transformer
 	 */
 	private synchronized void setEntry(String url, long lastModified, Transformer transformer) {
 		if (transformer != null) { 
 			TransformerEntry entry = new TransformerEntry(transformer, lastModified);
 			SoftReference ref = new SoftReference(entry);
 			transformations.put(url, ref);
 		} else {
 			transformations.remove(url);
 		}
 	}
 
 	/***
 	 * Create transformer from InputStream.
 	 * 
 	 * @param is
 	 *            InputStream to parse XSLT transformation from
 	 * @param url
 	 *            URL of the XSLT transformation
 	 * @return the Transformer, or null if error creating Transformer
 	 * @throws IOException
 	 *             if error reading from the InputStream
 	 */
 	private static Transformer createTransformer(InputStream is, URL url) throws IOException {
 		try {
 			Transformer t = null;
 			if (is != null) {
 				Source source = new StreamSource(is, url != null ? url.toString() : null);
 				t = TF.newTransformer(source);
 			} else {
 				throw new FileNotFoundException("Unable to find XSLT file " + url);
 			}
 			t.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 			t.setOutputProperty(OutputKeys.INDENT, "yes");
 			return t;
 		} catch (TransformerConfigurationException e) {
 			e.printStackTrace();
 			return null;
 		}
 	}
 	
 }
 
 /***
  * Transformer cache entry.
  * 
  * @author Fredrik Vraalsen
  */
 final class TransformerEntry {
 	
 	private Transformer transformer;
 	private long lastModified;
 	
 	/***
 	 * @param transformer the Transformer
 	 * @param lastModified last modification time of transformer
 	 */
 	protected TransformerEntry(Transformer transformer, long lastModified) {
 		this.transformer = transformer;
 		this.lastModified = lastModified;
 	}
 
 	/***
 	 * @return the Transformer
 	 */
 	public Transformer getTransformer() {
 		return transformer;
 	}
 	
 	/***
 	 * @return last modification time of the transformer
 	 */
 	public long getLastModified() {
 		return lastModified;
 	}
 	
 }