ClassTransformerFactory.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.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.URIResolver;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import biz.hammurapi.config.Context;
import biz.hammurapi.convert.ConvertingService;
import biz.hammurapi.eval.ExpandingFilterWriter;
import biz.hammurapi.xml.dom.DomSerializable;


/**
 * Finds class stylesheet and transforms given
 * object using the stylesheet.
 * @author Pavel Vlasov
 * @revision $Revision$
 */
public class ClassTransformerFactory {
	private static class Key {
		String className;
		String profile;
		Locale locale;
		
		public boolean equals(Object otherTemplateKey) {
			if (this==otherTemplateKey) {
				return true;
			}
			
			if (otherTemplateKey instanceof Key) {
				Key otk=(Key) otherTemplateKey;
				return className.equals(otk.className) 
					&& (profile==null ? otk.profile==null : profile.equals(otk.profile)) 
					&& (locale==null ? otk.locale==null : locale.equals(otk.locale));
			}
			
			return false;
		}
		
		public int hashCode() {
			return className.hashCode() ^ (profile==null ? 0 : profile.hashCode()) ^ (locale==null ? 0 : locale.hashCode());
		}
				
		/**
		 * @param className
		 * @param profile
		 * @param locale
		 */
		public Key(String className, String profile, Locale locale) {
			super();
			this.className = className;
			this.profile = profile;
			this.locale = locale;
		}
	}
	
	private Map templates=new HashMap();
	private Map contexts=new HashMap();
	private TransformerFactory factory = TransformerFactory.newInstance();
		
	private boolean cacheExpandedTemplates;
	private ClassTemplateResolver templateResolver;
	
	private Templates findTemplate(Class clazz, String profile, Locale locale, Context context) throws TransformerFactoryConfigurationError, TransformerConfigurationException, IOException {
		if (context==null || cacheExpandedTemplates) {
			synchronized (templates) {
				Key key=new Key(clazz.getName(), profile, locale);
				Templates ret=(Templates) templates.get(key);
				if (ret==null && !templates.containsKey(key)) {
					ret = loadTemplate(clazz, profile, locale, context);						
					templates.put(key, ret);
				}
				
				return ret;
			}
		}
		return loadTemplate(clazz, profile, locale, context);
	}
	
	/**
	 * @param clazz
	 * @param profile
	 * @param locale
	 * @param context
	 * @return
	 * @throws TransformerConfigurationException
	 * @throws IOException
	 */
	private Templates loadTemplate(Class clazz, String profile, Locale locale, final Context context) throws TransformerConfigurationException, IOException {
		InputStream is=null;
		if (templateResolver!=null) {
			is=templateResolver.resolve(clazz, profile, locale);			
		}	
		
		if (is==null) {
			is=new ClassResourceLoader(clazz).getResourceAsStream(profile, locale, "xsl");
		}
		
		if (is==null) {
			return null;
		}
		final Context classContext=findContext(clazz, profile, locale);
		if (classContext==null && context==null) {
			return factory.newTemplates(new StreamSource(is));
		}
		return factory.newTemplates(
				new StreamSource(
						ExpandingFilterWriter.expand(
								new InputStreamReader(is), 
								new Context() {

									public Object get(String name) {
										Object ret = context==null ? null : context.get(name);
										if (ret==null && classContext!=null) {
											ret=classContext.get(name);
										}
										return ret;
									}					
		})));
	}

	private Context findContext(Class clazz, String profile, Locale locale) {
		synchronized (contexts) {
			Key key=new Key(clazz.getName(), profile, locale);
			Context ret=(Context) contexts.get(key);
			if (ret==null && !contexts.containsKey(key)) {
				ret=new ClassResourceLoader(clazz).getContext(profile, locale, "ctx");
				contexts.put(key, ret);
			}
			
			return ret;
		}
	}
	
	/**
	 * Transforms object using object's class stylesheet. Collections are treated differently - for them
	 * a stylesheet of the first element with profile 'list' is used if profile is null. If there are no
	 * elements in the collection or if a stylesheet is not found then ClassTransformerFactory!list stylesheet is used.
	 * @param object
	 * @param profile
	 * @param locale
	 * @param parameters
	 * @param out
	 * @throws TransformerException
	 * @throws FactoryConfigurationError
	 * @throws ParserConfigurationException
	 * @throws TransformerFactoryConfigurationError
	 * @throws IOException
	 * @throws TransformerConfigurationException
	 */
	public void transform(
			final Object object, 
			String rootName, 
			String profile, 
			Locale locale,
			final Context expandContext,
			Properties parameters, 
			Result out) 
	throws 
			TransformerException, 
			ParserConfigurationException, 
			FactoryConfigurationError, 
			TransformerConfigurationException, 
			TransformerFactoryConfigurationError, 
			IOException {
		
		final Class[] clazz={null};
		Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
		Element root=doc.createElement(rootName==null ? "root" : rootName);
		doc.appendChild(root);
		
		final Locale actualLocale = locale==null ? Locale.getDefault() : locale;
		
		if (object instanceof Collection) {
			
			AbstractCollection src = new AbstractCollection() {

				public int size() {
					return ((Collection) object).size();
				}

				public Iterator iterator() {
					return new Iterator() {
						Iterator master=((Collection) object).iterator();

						public void remove() {
							master.remove();							
						}

						public boolean hasNext() {
							return master.hasNext();
						}

						public Object next() {
							Object ret=master.next();
							if (clazz[0]==null && ret!=null) {
								clazz[0]=ret.getClass();
							}
							return ret;
						}						
					};
				}
				
			};
			DomSerializable ds = (DomSerializable) ConvertingService.convert(src, DomSerializable.class);
			ds.toDom(root);
			
			if (clazz[0]==null) {
				clazz[0]=ClassTransformerFactory.class;				
			}
			
			if (profile==null) {
				profile="list";
			}
		} else {
			clazz[0]=object.getClass();
			DomSerializable ds = (DomSerializable) ConvertingService.convert(object, DomSerializable.class);
			ds.toDom(root);
		}				
		
		Templates template=findTemplate(clazz[0], profile, actualLocale, expandContext);
		if (template==null && object instanceof Collection) {
			template=findTemplate(ClassTransformerFactory.class, profile, actualLocale, expandContext);
		}
		
		Transformer transformer = template==null ? factory.newTransformer() : template.newTransformer();
		
		final URIResolver originalUriResolver = factory.getURIResolver();
		final String finalProfile=profile;
		transformer.setURIResolver(new URIResolver() {

			public Source resolve(String uri, String base) throws TransformerException {
				String resourceUriPrefix = biz.hammurapi.config.DomConfigFactory.RESOURCE_PREFIX;
				if (uri.equals(resourceUriPrefix+"super")) {
					final InputStream[] superResource={null};
					final Class[] superClass={null};
					new ClassHierarchyVisitable(clazz[0]).accept(new Visitor() {

						public boolean visit(Object target) {
							if (target!=clazz[0]) { 
								superClass[0]=(Class) target;
								
								if (templateResolver!=null) {
									superResource[0]=templateResolver.resolve(superClass[0], finalProfile, actualLocale);
								}
								
								if (superResource!=null) {
									return false;									
								}
								
								for (int i=0; i<4; i++) {
									String variant=superClass[0].getName().replace('.','/');
									if (finalProfile!=null) {
										variant+=finalProfile;
									}
									
									switch (i) {
										case 0:
											variant+=actualLocale;
											break;
										case 1:
											variant+="_"+actualLocale.getLanguage();
											if (actualLocale.getCountry().length()!=0) {
												variant+="_"+actualLocale.getCountry();
											}
											break;
										case 2:
											variant+="_"+actualLocale.getLanguage();
											break;
										case 3:
											break;							
									}
									
									variant+=".xsl";
									
									
									superResource[0]=clazz[0].getClassLoader().getResourceAsStream(variant);
									if (superResource[0]!=null) {
										return false;
									}
								}
							}
																		
							return true;
						}
						
					});
					
					if (superResource[0]==null) {
						throw new TransformerException("Cannot resolve: "+uri);
					}
					
					try {
						return new StreamSource(
								ExpandingFilterWriter.expand(
									new InputStreamReader(superResource[0]), 
									new Context() {
	
										public Object get(String name) {
											Object ret = expandContext==null ? null : expandContext.get(name);
											final Context classContext=findContext(superClass[0], finalProfile, actualLocale);
											if (ret==null && classContext!=null) {
												ret=classContext.get(name);
											}
											return ret;
										}
									}));						
					} catch (IOException e) {
						throw new TransformerException(e);
					}					
				} else if (uri.startsWith(resourceUriPrefix)) {
					try {
						final Class resourceClass = clazz[0].getClassLoader().loadClass(uri.substring(resourceUriPrefix.length()));
						ClassResourceLoader crl=new ClassResourceLoader(resourceClass);
						InputStream is=crl.getResourceAsStream(finalProfile, actualLocale, "xsl");
						if (is==null) {
							throw new TransformerException("Cannot resolve: "+uri);
						}
						return new StreamSource(
								ExpandingFilterWriter.expand(
									new InputStreamReader(is), 
									new Context() {
	
										public Object get(String name) {
											Object ret = expandContext==null ? null : expandContext.get(name);
											final Context classContext=findContext(resourceClass, finalProfile, actualLocale);
											if (ret==null && classContext!=null) {
												ret=classContext.get(name);
											}
											return ret;
										}
									}));						
						
					} catch (ClassNotFoundException e) {
						throw new TransformerException(e);
					} catch (IOException e) {
						throw new TransformerException(e);
					}
				}
								
				return originalUriResolver.resolve(uri, base);
			}
			
		});		
		
		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), out);
	}		
	
	public ClassTransformerFactory(ClassTemplateResolver templateResolver, boolean cacheExpandedTemplates) {
		this.templateResolver=templateResolver;
		this.cacheExpandedTemplates=cacheExpandedTemplates;
	}
}