AbstractRenderer.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.render.dom;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.w3c.dom.Element;

import biz.hammurapi.config.Parameterizable;
import biz.hammurapi.render.RenderRequest;
import biz.hammurapi.render.RenderingException;


/**
 *
 * @author  Pavel Vlasov
 * @version $Revision: 1.5 $
 */
public abstract class AbstractRenderer implements DomRenderer, Parameterizable {
    private static class StyleKey {
        Class clazz;
        String profile;
        
        public StyleKey(Class clazz, String profile) {
            super();
            this.clazz = clazz;
            this.profile = profile;
        }
        
        public boolean equals(Object obj) {
            if (obj==this) {
                return true;
            } else if (obj instanceof StyleKey) {
                StyleKey otherKey=(StyleKey) obj;
                if (clazz.equals(otherKey.clazz)) {
                    if (profile==null) {
                        return otherKey.profile==null;
                    } else if (otherKey.profile==null) {
                        return false;
                    } else {
                        return profile.equals(otherKey.profile);
                    }
                }
				return false;
            } else {
                return super.equals(obj);
            }
        }
        
        public int hashCode() {
            int ret=clazz.hashCode();
            if (profile!=null) {
                ret^=profile.hashCode();
            }
            return ret;
        }
    }
    
    private static Map styleMap=new HashMap();
    
    protected RenderRequest request;
    protected String profile;
    public static final String PROFILE_SEPARATOR="!";
       
    protected AbstractRenderer(RenderRequest request) {
        this.request=request;
    }
    
    protected AbstractRenderer(RenderRequest request, String profile) {
        this.request=request;
        this.profile=profile;
    }
    
    /**
     * Searches for class name first, then for all interfaces and then for
     * superclass.
     * @param clazz
     * @return
     * @throws TransformerConfigurationException
     */
    public synchronized Transformer getEmbeddedStyle(Class clazz) throws TransformerConfigurationException {
        StyleKey key=new StyleKey(clazz, profile);
        Templates templates=(Templates) styleMap.get(key);
        if (templates==null) {
            String transletClass=clazz.getName()+StyleCompiler.POSTFIX;
            if (profile!=null) {
                transletClass+=StyleCompiler.TRANSLET_PROFILE_SEPARATOR+profile;
            }
            
//            try {

//                getClass().getClassLoader().loadClass(transletClass);

//                int idx=transletClass.lastIndexOf('.');

//        		TransformerFactory tf=new TransformerFactoryImpl();

//                tf.setAttribute("use-classpath", Boolean.TRUE);

//                if (idx!=-1) {

//                	tf.setAttribute("package-name", transletClass.substring(0, idx));

//                }

//        		templates=tf.newTemplates(new StreamSource(idx==-1 ? transletClass : transletClass.substring(idx+1)));

//        		styleMap.put(key, templates);

//        		return templates.newTransformer();

//            } catch (ClassNotFoundException e) {

	            String resourceName=clazz.getName().replace('.','/')+(profile==null ? "" : PROFILE_SEPARATOR+profile)+".xsl";
	            InputStream rets=getClass().getClassLoader().getResourceAsStream(resourceName);
	            if (rets!=null) {
	                TransformerFactory tf=TransformerFactory.newInstance();
	                templates=tf.newTemplates(new StreamSource(rets));
	                styleMap.put(key, templates);
	                return templates.newTransformer();
	            }
//            }

            
            Class[] interfaces = clazz.getInterfaces();
    		for (int i=0; i<interfaces.length; i++) {
    			Transformer rett=getEmbeddedStyle(interfaces[i]);
    			if (rett!=null) {
    				return rett;
    			}
            }
    		
    		if (clazz.getSuperclass()==null) {
    		    styleMap.put(key, null);
    		    return null;
    		}
			return getEmbeddedStyle(clazz.getSuperclass());
        }
		return templates.newTransformer();
    }    
    
    public RenderRequest render(OutputStream out) throws RenderingException {
        return render(null, out);
    }
    
    public RenderRequest render(InputStream style, OutputStream out) throws RenderingException {
        try {
            Transformer transformer=null;

            if (style==null && useEmbeddedStyle) {
                transformer=getEmbeddedStyle(request.getRenderee().getClass());
            } 
            
            if (transformer==null) {
                TransformerFactory tFactory = TransformerFactory.newInstance();                
                transformer =
                    style==null ?
                        tFactory.newTransformer() :
                        tFactory.newTransformer(new StreamSource(style));
            }

            Iterator pit=params.entrySet().iterator();
            while (pit.hasNext()) {
                Map.Entry entry=(Map.Entry) pit.next();
                transformer.setParameter((String) entry.getKey(), entry.getValue());
            }

            DocumentBuilder builder=null;
            
            if (request.getDocument()==null) {
	            DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
	            builder=factory.newDocumentBuilder();
	            request.setDocument(builder.newDocument());
	            request.getDocument().appendChild(render(request.getDocument()));
            }
            
            DOMSource domSource = new DOMSource(request.getDocument());
            transformer.transform(domSource, new StreamResult(out));
            out.close();
            return request;
        } catch (TransformerConfigurationException e) {
            throw new RenderingException(e.toString(), e);
        } catch (ParserConfigurationException e) {
            throw new RenderingException(e.toString(), e);
        } catch (TransformerException e) {
            throw new RenderingException(e.toString(), e);
        } catch (UnsupportedEncodingException e) {
            throw new RenderingException(e.toString(), e);
        } catch (IOException e) {
            throw new RenderingException(e.toString(), e);
        }            
    }

    protected boolean useEmbeddedStyle=true;
    
    public void setEmbeddedStyle(boolean useEmbeddedStyle) {
        this.useEmbeddedStyle=useEmbeddedStyle;
    }
        
    protected Map params=new HashMap();
    
    public boolean setParameter(String name, Object value) {
        params.put(name, value);
        return true;
    }

	/**
	 * Creates and add element with text if text!=null && name!=null
	 * @param name
	 * @param text
	 * @param owner
	 * @return
	 */
	public static void appendTextElement(String name, String text, Element owner) {
		if (name!=null && text!=null) {
			Element e=owner.getOwnerDocument().createElement(name);
			owner.appendChild(e);
			e.appendChild(owner.getOwnerDocument().createTextNode(text));
		}
	}
}