Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  *
  *
  * This file incorporates work covered by the following copyright and
  * permission notice:
  *
  * Copyright 2004 The Apache Software Foundation
  *
  * Licensed 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.taglibs.standard.tag.common.xml;
 
 import java.io.Reader;
 import java.io.Writer;
 import java.util.List;
 
 

Support for tag handlers for <transform>, the XML transformation tag.

Author(s):
Shawn Bayern
public abstract class TransformSupport extends BodyTagSupport {
    //*********************************************************************
    // Protected state
    protected Object xml;                       // attribute
    protected String xmlSystemId;		// attribute
    protected Object xslt;			// attribute
    protected String xsltSystemId;		// attribute
    protected Result result;			// attribute
    //*********************************************************************
    // Private state
    private String var;                            // 'var' attribute
    private int scope;				   // processed 'scope' attr
    private Transformer t;			   // actual Transformer
    private TransformerFactory tf;		   // reusable factory
    private DocumentBuilder db;			   // reusable factory
    private DocumentBuilderFactory dbf;		   // reusable factory
    //*********************************************************************
    // Constructor and initialization
    public TransformSupport() {
	super();
    }
    private void init() {
	 =  = null;
	 = null;
	 = null;
	 = null;
         = .;
    }
    //*********************************************************************
    // Tag logic
    public int doStartTag() throws JspException {
      /*
       * We can set up our Transformer here, so we do so, and we let
       * it receive parameters directly from subtags (instead of
       * caching them.
       */
      try {
	//************************************
	// Initialize
	// set up our DocumentBuilderFactory if necessary
	if ( == null) {
	     = DocumentBuilderFactory.newInstance();
            .setNamespaceAware(true);
            .setValidating(false);
	}
        if ( == null)
	     = .newDocumentBuilder();
	// set up the TransformerFactory if necessary
        if ( == null)
             = TransformerFactory.newInstance();
	//************************************
	// Produce transformer
	if ( != null) {
	    if (!( instanceof String) && !( instanceof Reader)
                    && !( instanceof javax.xml.transform.Source))
		throw new JspTagException(
		    Resources.getMessage("TRANSFORM_XSLT_UNRECOGNIZED"));
	    s = getSource();
else {
	    throw new JspTagException(
	        Resources.getMessage("TRANSFORM_NO_TRANSFORMER"));
        }
         = .newTransformer(s);
      } catch (SAXException ex) {
	throw new JspException(ex);
      } catch (ParserConfigurationException ex) {
	throw new JspException(ex);
      } catch (IOException ex) {
	throw new JspException(ex);
      } catch (TransformerConfigurationException ex) {
	throw new JspException(ex);
      }
    }
    // parse 'xml' or body, transform via our Transformer,
    // and store as 'var' or through 'result'
    public int doEndTag() throws JspException {
      try {
	//************************************
	// Determine source XML
	// if we haven't gotten a source, use the body (which may be empty)
	Object xml = this.;
	if (xml == null)				// still equal
	    if ( != null && .getString() != null)
	        xml = .getString().trim();
	    else
		xml = "";
	// let the Source be with you
	Source source = getSource(xml);
	//************************************
	// Conduct the transformation
	// we can assume at most one of 'var' or 'result' is specified
	if ( != null)
	    // we can write directly to the Result
	    .transform(source);
	else if ( != null) {
	    // we need a Document
	    Document d = .newDocument();
	    Result doc = new DOMResult(d);
	    .transform(sourcedoc);
else {
	    Result page =
	    .transform(sourcepage);
	}
	return ;
      } catch (SAXException ex) {
	throw new JspException(ex);
      } catch (ParserConfigurationException ex) {
	throw new JspException(ex);
      } catch (IOException ex) {
	throw new JspException(ex);
      } catch (TransformerException ex) {
	throw new JspException(ex);
      }
    }
    // Releases any resources we may have (or inherit)
    public void release() {
    }
    //*********************************************************************
    // Public methods for subtags

    
Sets (adds) a transformation parameter on our transformer.
    public void addParameter(String nameObject value) {
	.setParameter(namevalue);
    }
    //*********************************************************************
    // Utility methods

    
Wraps systemId with a "jstl:" prefix to prevent the parser from thinking that the URI is truly relative and resolving it against the current directory in the filesystem.
    private static String wrapSystemId(String systemId) {
      if (systemId == null)
          return "jstl:";
      else if (ImportSupport.isAbsoluteUrl(systemId))
          return systemId;
      else
          return ("jstl:" + systemId);
    }

    
Retrieves a Source from the given Object, whether it be a String, Reader, Node, or other supported types (even a Source already). If 'url' is true, then we must be passed a String and will interpret it as a URL. A null input always results in a null output.
    private Source getSource(Object oString systemId)
	if (o == null)
	    return null;
        else if (o instanceof Source) {
	    return (Sourceo;
        } else if (o instanceof String) {
	    // if we've got a string, chain to Reader below
	    return getSource(new StringReader((Stringo), systemId);
        } else if (o instanceof Reader) {
	    // explicitly go through SAX to maintain control
	    // over how relative external entities resolve
            XMLReader xr = XMLReaderFactory.createXMLReader();
            xr.setEntityResolver(
                new ParseSupport.JstlEntityResolver());
            InputSource s = new InputSource((Readero);
            s.setSystemId(wrapSystemId(systemId));
            Source result = new SAXSource(xrs);
            result.setSystemId(wrapSystemId(systemId));
	    return result;
        } else if (o instanceof Node) {
	    return new DOMSource((Nodeo);
        } else if (o instanceof List) {
	    // support 1-item List because our XPath processor outputs them	
	    List l = (Listo;
	    if (l.size() == 1) {
	        return getSource(l.get(0), systemId);		// unwrap List
	    } else {
	        throw new IllegalArgumentException(
                  Resources.getMessage("TRANSFORM_SOURCE_INVALID_LIST"));
	    }
        } else {
	    throw new IllegalArgumentException(
	       Resources.getMessage("TRANSFORM_SOURCE_UNRECOGNIZED")
	         + o.getClass());
	}
    }
    //*********************************************************************
    // Tag attributes
    public void setVar(String var) {
	this. = var;
    }
    public void setScope(String scope) {
        this. = Util.getScope(scope);
    }
    //*********************************************************************
    // Private utility classes

    
A Writer based on a wrapped Writer but ignoring requests to close() and flush() it. (Someone must have wrapped the toilet in my office similarly...)
    private static class SafeWriter extends Writer {
	private Writer w;
	public SafeWriter(Writer w) { this. = w; }
	public void close() { }
	public void flush() { }
	public void write(char[] cbufint offint lenthrows IOException {
	    .write(cbufofflen);
	}
    }	
    //*********************************************************************
    // JSTL-specific URIResolver class

    
Lets us resolve relative external entities.
    private static class JstlUriResolver implements URIResolver {
        private final PageContext ctx;
        public JstlUriResolver(PageContext ctx) {
            this. = ctx;
        }
        public Source resolve(String hrefString base)
	        throws TransformerException {
            // pass if we don't have a systemId
            if (href == null)
                return null;
	    // remove "jstl" marker from 'base'
            // NOTE: how 'base' is determined varies among different Xalan
            // xsltc implementations
            int index;
            if (base != null && (index = base.indexOf("jstl:")) != -1) {
                base = base.substring(index + 5);
            }  
            // we're only concerned with relative URLs
            if (ImportSupport.isAbsoluteUrl(href)
		    || (base != null && ImportSupport.isAbsoluteUrl(base)))
                return null;
	    // base is relative; remove everything after trailing '/'
	    if (base == null || base.lastIndexOf("/") == -1)
		base = "";
	    else
		base = base.substring(0, base.lastIndexOf("/") + 1);
	    // concatenate to produce the real URL we're interested in
	    String target = base + href;	    
            // for relative URLs, load and wrap the resource.
            // don't bother checking for 'null' since we specifically want
            // the parser to fail if the resource doesn't exist
            InputStream s;
            if (target.startsWith("/")) {
                s = .getServletContext().getResourceAsStream(target);
                if (s == null)
                    throw new TransformerException(
                        Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                         href));
            } else {
                String pagePath =
                    ((HttpServletRequest.getRequest()).getServletPath();
                String basePath =
                    pagePath.substring(0, pagePath.lastIndexOf("/"));
                s = .getServletContext().getResourceAsStream(
                      basePath + "/" + target);
		if (s == null)
		    throw new TransformerException(
                        Resources.getMessage("UNABLE_TO_RESOLVE_ENTITY",
                         href));
            }
            return new StreamSource(s);
        }
    }
New to GrepCode? Check out our FAQ X