java/src/org/apache/qetest/xslwrapper/XTWrapper.java - xalan-test - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you 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.
  */
 /*
  * $Id$
  */

 package org.apache.qetest.xslwrapper;

 import java.io.File;
 import java.net.URL;
 import java.util.Hashtable;
 import java.util.Properties;

 import org.xml.sax.InputSource;

 /**
  * Implementation of TransformWrapper that uses the simplest method
  * possible to use James Clark's XT processor.
  *
  * @author Shane Curcuru
  * @version $Id$
  */
 public class XTWrapper extends TransformWrapperHelper
 {

     /**
      * Get a general description of this wrapper itself.
      *
      * @return Uses XT in simplest manner possible
      */
     public String getDescription()
     {
         return "Uses XT in simplest manner possible";
     }


     /** No-op Ctor for the Xalan-J 1.x wrapper. */
     public XTWrapper(){}

     /** Reference to current processor - XT flavor - convenience method. */
     protected com.jclark.xsl.sax.XSLProcessorImpl processor = null;

     /**
      * Cached copy of newProcessor() Hashtable.
      */
     protected Hashtable newProcessorOpts = null;

     /**
      * Get a specific description of the wrappered processor.
      *
      * @return specific description of the underlying processor or
      * transformer implementation: this should include both the
      * general product name, as well as specific version info.  If
      * possible, should be implemented without actively creating
      * an underlying processor.
      */
     public Properties getProcessorInfo()
     {
         Properties p = new Properties();
         p.put("traxwrapper.method", "simple");
         p.put("traxwrapper.desc", getDescription());
         //@todo call XT to find version info
         return p;
     }

     /**
      * Actually create/initialize an underlying processor or factory.
      * This creates a com.jclark.xsl.sax.XSLProcessorImpl.
      *
      * @param options Hashtable of options, unused.
      *
      * @return (Object)getProcessor() as a side-effect, this will
      * be null if there was any problem creating the processor OR
      * if the underlying implementation doesn't use this
      *
      * @throws Exception covers any underlying exceptions thrown
      * by the actual implementation
      */
     public Object newProcessor(Hashtable options) throws Exception
     {
         newProcessorOpts = options;
         // Cleanup any prior objects
         reset(false);

         processor = new com.jclark.xsl.sax.XSLProcessorImpl();

         String liaisonClassName = "com.jclark.xml.sax.CommentDriver";  // default

         try
         {
             Object parserObj = Class.forName(liaisonClassName).newInstance();

             if (parserObj instanceof XMLProcessorEx)
                 processor.setParser((XMLProcessorEx) parserObj);
             else
                 processor.setParser((org.xml.sax.Parser) parserObj);
         }
         catch (Exception e)
         {
             System.err.println("createNewProcesor(xt) threw: "
                                + e.toString());
             e.printStackTrace();

             processor = null;
         }

         return (Object)processor;
     }

     /**
      * Transform supplied xmlName file with the stylesheet in the
      * xslName file into a resultName file using XT.
      *
      * @param xmlName local path\filename of XML file to transform
      * @param xslName local path\filename of XSL stylesheet to use
      * @param resultName local path\filename to put result in
      *
      * @return array of longs denoting timing of all parts of
      * our operation: IDX_OVERALL, IDX_XSLREAD, IDX_XSLBUILD,
      * IDX_TRANSFORM, IDX_RESULTWRITE
      *
      * @throws Exception any underlying exceptions from the
      * wrappered processor are simply allowed to propagate; throws
      * a RuntimeException if any other problems prevent us from
      * actually completing the operation
      */
     public long[] transform(String xmlName, String xslName, String resultName)
         throws Exception
     {
         // Declare variables ahead of time to minimize latency
         long startTime = 0;
         long endTime = 0;

         // Create XT-specific sources
         OutputMethodHandlerImpl outHandler =
             new OutputMethodHandlerImpl(processor);

         outHandler.setDestination(new FileDestination(new File(resultName)));

         InputSource xmlIS = xtInputSourceFromString(xmlName);
         InputSource xslIS = xtInputSourceFromString(xslName);

         // Begin timing the process: stylesheet, output, and process
         startTime = System.currentTimeMillis();

         processor.loadStylesheet(xslIS);
         processor.setOutputMethodHandler(outHandler);
         processor.parse(xmlIS);

         endTime = System.currentTimeMillis();

         long[] times = getTimeArray();
         times[IDX_OVERALL] = endTime - startTime;
         return times;
     }


     /**
      * Pre-build/pre-compile a stylesheet.
      *
      * Although the actual mechanics are implementation-dependent,
      * most processors have some method of pre-setting up the data
      * needed by the stylesheet itself for later use in transforms.
      * In TrAX/javax.xml.transform, this equates to creating a
      * Templates object.
      *
      * Sets isStylesheetReady() to true if it succeeds.  Users can
      * then call transformWithStylesheet(xmlName, resultName) to
      * actually perform a transformation with this pre-built
      * stylesheet.
      *
      * @param xslName local path\filename of XSL stylesheet to use
      *
      * @return array of longs denoting timing of all parts of
      * our operation: IDX_OVERALL, IDX_XSLBUILD
      *
      * @throws Exception any underlying exceptions from the
      * wrappered processor are simply allowed to propagate; throws
      * a RuntimeException if any other problems prevent us from
      * actually completing the operation
      *
      * @see #transformWithStylesheet(String xmlName, String resultName)
      */
     public long[] buildStylesheet(String xslName) throws Exception
     {
         // Declare variables ahead of time to minimize latency
         long startTime = 0;
         long endTime = 0;

         // Create XT-specific source
         InputSource xslIS = xtInputSourceFromString(xslName);

         // Begin timing loading the stylesheet
         startTime = System.currentTimeMillis();

         processor.loadStylesheet(xslIS);  // side effect: also sets the stylesheet

         endTime = System.currentTimeMillis();
         m_stylesheetReady = true;

         long[] times = getTimeArray();
         times[IDX_OVERALL] = endTime - startTime;
         return times;
     }

     /**
      * Transform supplied xmlName file with a pre-built/pre-compiled
      * stylesheet into a resultName file.
      *
      * User must have called buildStylesheet(xslName) beforehand,
      * obviously.
      * Names are assumed to be local path\filename references, and
      * will be converted to URLs as needed.
      *
      * @param xmlName local path\filename of XML file to transform
      * @param resultName local path\filename to put result in
      *
      * @return array of longs denoting timing of all parts of
      * our operation: IDX_OVERALL,
      * IDX_XMLREAD, IDX_TRANSFORM, IDX_RESULTWRITE
      *
      * @throws Exception any underlying exceptions from the
      * wrappered processor are simply allowed to propagate; throws
      * a RuntimeException if any other problems prevent us from
      * actually completing the operation; throws an
      * IllegalStateException if isStylesheetReady() == false.
      *
      * @see #buildStylesheet(String xslName)
      */
     public long[] transformWithStylesheet(String xmlName, String resultName)
         throws Exception
     {
         if (!isStylesheetReady())
             throw new IllegalStateException("transformWithStylesheet() when isStylesheetReady() == false");

         // Declare variables ahead of time to minimize latency
         long startTime = 0;
         long endTime = 0;

         // Create XT-specific sources
         OutputMethodHandlerImpl outHandler =
             new OutputMethodHandlerImpl(processor);

         outHandler.setDestination(new FileDestination(new File(resultName)));

         InputSource xmlIS = xtInputSourceFromString(xmlName);

         // Begin timing the process: stylesheet, output, and process
         startTime = System.currentTimeMillis();

         processor.setOutputMethodHandler(outHandler);
         processor.parse(xmlIS);

         endTime = System.currentTimeMillis();

         long[] times = getTimeArray();
         times[IDX_OVERALL] = endTime - startTime;
         return times;
     }

     /**
      * Transform supplied xmlName file with a stylesheet found in an
      * xml-stylesheet PI into a resultName file.
      *
      * Names are assumed to be local path\filename references, and
      * will be converted to URLs as needed.  Implementations will
      * use whatever facilities exist in their wrappered processor
      * to fetch and build the stylesheet to use for the transform.
      *
      * @param xmlName local path\filename of XML file to transform
      * @param resultName local path\filename to put result in
      *
      * @return array of longs denoting timing of only these parts of
      * our operation: IDX_OVERALL, IDX_XSLREAD (time to find XSL
      * reference from the xml-stylesheet PI), IDX_XSLBUILD, (time
      * to then build the Transformer therefrom), IDX_TRANSFORM
      *
      * @throws Exception any underlying exceptions from the
      * wrappered processor are simply allowed to propagate; throws
      * a RuntimeException if any other problems prevent us from
      * actually completing the operation
      */
     public long[] transformEmbedded(String xmlName, String resultName)
         throws Exception
     {
         throw new RuntimeException("XTWrapper.transformEmbedded not implemented yet!");
     }

     /**
      * Worker method for using XT to process.
      *
      * @param name local name of file
      *
      * @return InputSource for XT after munging name as needed
      */
     private InputSource xtInputSourceFromString(String name)
     {

         File file = new File(name);
         String path = file.getAbsolutePath();

         // Add absolute / to beginning if needed
         if (path.charAt(0) != '/')
             path = '/' + path;

         try
         {
             java.net.URL temp = new URL("file", "", path);

             return (new InputSource(temp.toString()));
         }
         catch (Exception e)
         {
             System.err.println("xtInputSourceFromString(xt) of: " + name
                                + " threw: " + e.toString());
             e.printStackTrace();

             return (null);
         }
     }

     /**
      * Reset our parameters and wrapper state, and optionally
      * force creation of a new underlying processor implementation.
      *
      * This always clears our built stylesheet and any parameters
      * that have been set.  If newProcessor is true, also forces a
      * re-creation of our underlying processor as if by calling
      * newProcessor().
      *
      * @param newProcessor if we should reset our underlying
      * processor implementation as well
      */
     public void reset(boolean newProcessor)
     {
         super.reset(newProcessor); // clears indent and parameters
         m_stylesheetReady = false;
         if (newProcessor)
         {
             try
             {
                 newProcessor(newProcessorOpts);
             }
             catch (Exception e)
             {
                 //@todo Hmm: what should we do here?
             }
         }
     }

     /**
      * Apply a single parameter to a Transformer.
      *
      * Overridden for XT to call setParameter().
      *
      * @param passThru to be passed to each applyParameter() method
      * call - for TrAX, you might pass a Transformer object.
      * @param namespace for the parameter, may be null
      * @param name for the parameter, should not be null
      * @param value for the parameter, may be null
      */
     protected void applyParameter(Object passThru, String namespace,
                                   String name, Object value)
     {
         try
         {
             XSLProcessorImpl p = (XSLProcessorImpl)passThru;
             //@todo: HACK: smash the namespace in - not sure if this is correct
             if (null != namespace)
             {
                 name = namespace + ":" + name;
             }
             p.setParameter(name, value);
         }
         catch (Exception e)
         {
             throw new IllegalArgumentException("applyParameter threw: " + e.toString());
         }
     }

 }  // end of class XTWrapper
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*/
	/*
	* $Id$
	*/

	package org.apache.qetest.xslwrapper;

	import java.io.File;
	import java.net.URL;
	import java.util.Hashtable;
	import java.util.Properties;

	import org.xml.sax.InputSource;

	/**
	* Implementation of TransformWrapper that uses the simplest method
	* possible to use James Clark's XT processor.
	*
	* @author Shane Curcuru
	* @version $Id$
	*/
	public class XTWrapper extends TransformWrapperHelper
	{

	/**
	* Get a general description of this wrapper itself.
	*
	* @return Uses XT in simplest manner possible
	*/
	public String getDescription()
	{
	return "Uses XT in simplest manner possible";
	}


	/** No-op Ctor for the Xalan-J 1.x wrapper. */
	public XTWrapper(){}

	/** Reference to current processor - XT flavor - convenience method. */
	protected com.jclark.xsl.sax.XSLProcessorImpl processor = null;

	/**
	* Cached copy of newProcessor() Hashtable.
	*/
	protected Hashtable newProcessorOpts = null;

	/**
	* Get a specific description of the wrappered processor.
	*
	* @return specific description of the underlying processor or
	* transformer implementation: this should include both the
	* general product name, as well as specific version info. If
	* possible, should be implemented without actively creating
	* an underlying processor.
	*/
	public Properties getProcessorInfo()
	{
	Properties p = new Properties();
	p.put("traxwrapper.method", "simple");
	p.put("traxwrapper.desc", getDescription());
	//@todo call XT to find version info
	return p;
	}

	/**
	* Actually create/initialize an underlying processor or factory.
	* This creates a com.jclark.xsl.sax.XSLProcessorImpl.
	*
	* @param options Hashtable of options, unused.
	*
	* @return (Object)getProcessor() as a side-effect, this will
	* be null if there was any problem creating the processor OR
	* if the underlying implementation doesn't use this
	*
	* @throws Exception covers any underlying exceptions thrown
	* by the actual implementation
	*/
	public Object newProcessor(Hashtable options) throws Exception
	{
	newProcessorOpts = options;
	// Cleanup any prior objects
	reset(false);

	processor = new com.jclark.xsl.sax.XSLProcessorImpl();

	String liaisonClassName = "com.jclark.xml.sax.CommentDriver"; // default

	try
	{
	Object parserObj = Class.forName(liaisonClassName).newInstance();

	if (parserObj instanceof XMLProcessorEx)
	processor.setParser((XMLProcessorEx) parserObj);
	else
	processor.setParser((org.xml.sax.Parser) parserObj);
	}
	catch (Exception e)
	{
	System.err.println("createNewProcesor(xt) threw: "
	+ e.toString());
	e.printStackTrace();

	processor = null;
	}

	return (Object)processor;
	}

	/**
	* Transform supplied xmlName file with the stylesheet in the
	* xslName file into a resultName file using XT.
	*
	* @param xmlName local path\filename of XML file to transform
	* @param xslName local path\filename of XSL stylesheet to use
	* @param resultName local path\filename to put result in
	*
	* @return array of longs denoting timing of all parts of
	* our operation: IDX_OVERALL, IDX_XSLREAD, IDX_XSLBUILD,
	* IDX_TRANSFORM, IDX_RESULTWRITE
	*
	* @throws Exception any underlying exceptions from the
	* wrappered processor are simply allowed to propagate; throws
	* a RuntimeException if any other problems prevent us from
	* actually completing the operation
	*/
	public long[] transform(String xmlName, String xslName, String resultName)
	throws Exception
	{
	// Declare variables ahead of time to minimize latency
	long startTime = 0;
	long endTime = 0;

	// Create XT-specific sources
	OutputMethodHandlerImpl outHandler =
	new OutputMethodHandlerImpl(processor);

	outHandler.setDestination(new FileDestination(new File(resultName)));

	InputSource xmlIS = xtInputSourceFromString(xmlName);
	InputSource xslIS = xtInputSourceFromString(xslName);

	// Begin timing the process: stylesheet, output, and process
	startTime = System.currentTimeMillis();

	processor.loadStylesheet(xslIS);
	processor.setOutputMethodHandler(outHandler);
	processor.parse(xmlIS);

	endTime = System.currentTimeMillis();

	long[] times = getTimeArray();
	times[IDX_OVERALL] = endTime - startTime;
	return times;
	}


	/**
	* Pre-build/pre-compile a stylesheet.
	*
	* Although the actual mechanics are implementation-dependent,
	* most processors have some method of pre-setting up the data
	* needed by the stylesheet itself for later use in transforms.
	* In TrAX/javax.xml.transform, this equates to creating a
	* Templates object.
	*
	* Sets isStylesheetReady() to true if it succeeds. Users can
	* then call transformWithStylesheet(xmlName, resultName) to
	* actually perform a transformation with this pre-built
	* stylesheet.
	*
	* @param xslName local path\filename of XSL stylesheet to use
	*
	* @return array of longs denoting timing of all parts of
	* our operation: IDX_OVERALL, IDX_XSLBUILD
	*
	* @throws Exception any underlying exceptions from the
	* wrappered processor are simply allowed to propagate; throws
	* a RuntimeException if any other problems prevent us from
	* actually completing the operation
	*
	* @see #transformWithStylesheet(String xmlName, String resultName)
	*/
	public long[] buildStylesheet(String xslName) throws Exception
	{
	// Declare variables ahead of time to minimize latency
	long startTime = 0;
	long endTime = 0;

	// Create XT-specific source
	InputSource xslIS = xtInputSourceFromString(xslName);

	// Begin timing loading the stylesheet
	startTime = System.currentTimeMillis();

	processor.loadStylesheet(xslIS); // side effect: also sets the stylesheet

	endTime = System.currentTimeMillis();
	m_stylesheetReady = true;

	long[] times = getTimeArray();
	times[IDX_OVERALL] = endTime - startTime;
	return times;
	}

	/**
	* Transform supplied xmlName file with a pre-built/pre-compiled
	* stylesheet into a resultName file.
	*
	* User must have called buildStylesheet(xslName) beforehand,
	* obviously.
	* Names are assumed to be local path\filename references, and
	* will be converted to URLs as needed.
	*
	* @param xmlName local path\filename of XML file to transform
	* @param resultName local path\filename to put result in
	*
	* @return array of longs denoting timing of all parts of
	* our operation: IDX_OVERALL,
	* IDX_XMLREAD, IDX_TRANSFORM, IDX_RESULTWRITE
	*
	* @throws Exception any underlying exceptions from the
	* wrappered processor are simply allowed to propagate; throws
	* a RuntimeException if any other problems prevent us from
	* actually completing the operation; throws an
	* IllegalStateException if isStylesheetReady() == false.
	*
	* @see #buildStylesheet(String xslName)
	*/
	public long[] transformWithStylesheet(String xmlName, String resultName)
	throws Exception
	{
	if (!isStylesheetReady())
	throw new IllegalStateException("transformWithStylesheet() when isStylesheetReady() == false");

	// Declare variables ahead of time to minimize latency
	long startTime = 0;
	long endTime = 0;

	// Create XT-specific sources
	OutputMethodHandlerImpl outHandler =
	new OutputMethodHandlerImpl(processor);

	outHandler.setDestination(new FileDestination(new File(resultName)));

	InputSource xmlIS = xtInputSourceFromString(xmlName);

	// Begin timing the process: stylesheet, output, and process
	startTime = System.currentTimeMillis();

	processor.setOutputMethodHandler(outHandler);
	processor.parse(xmlIS);

	endTime = System.currentTimeMillis();

	long[] times = getTimeArray();
	times[IDX_OVERALL] = endTime - startTime;
	return times;
	}

	/**
	* Transform supplied xmlName file with a stylesheet found in an
	* xml-stylesheet PI into a resultName file.
	*
	* Names are assumed to be local path\filename references, and
	* will be converted to URLs as needed. Implementations will
	* use whatever facilities exist in their wrappered processor
	* to fetch and build the stylesheet to use for the transform.
	*
	* @param xmlName local path\filename of XML file to transform
	* @param resultName local path\filename to put result in
	*
	* @return array of longs denoting timing of only these parts of
	* our operation: IDX_OVERALL, IDX_XSLREAD (time to find XSL
	* reference from the xml-stylesheet PI), IDX_XSLBUILD, (time
	* to then build the Transformer therefrom), IDX_TRANSFORM
	*
	* @throws Exception any underlying exceptions from the
	* wrappered processor are simply allowed to propagate; throws
	* a RuntimeException if any other problems prevent us from
	* actually completing the operation
	*/
	public long[] transformEmbedded(String xmlName, String resultName)
	throws Exception
	{
	throw new RuntimeException("XTWrapper.transformEmbedded not implemented yet!");
	}

	/**
	* Worker method for using XT to process.
	*
	* @param name local name of file
	*
	* @return InputSource for XT after munging name as needed
	*/
	private InputSource xtInputSourceFromString(String name)
	{

	File file = new File(name);
	String path = file.getAbsolutePath();

	// Add absolute / to beginning if needed
	if (path.charAt(0) != '/')
	path = '/' + path;

	try
	{
	java.net.URL temp = new URL("file", "", path);

	return (new InputSource(temp.toString()));
	}
	catch (Exception e)
	{
	System.err.println("xtInputSourceFromString(xt) of: " + name
	+ " threw: " + e.toString());
	e.printStackTrace();

	return (null);
	}
	}

	/**
	* Reset our parameters and wrapper state, and optionally
	* force creation of a new underlying processor implementation.
	*
	* This always clears our built stylesheet and any parameters
	* that have been set. If newProcessor is true, also forces a
	* re-creation of our underlying processor as if by calling
	* newProcessor().
	*
	* @param newProcessor if we should reset our underlying
	* processor implementation as well
	*/
	public void reset(boolean newProcessor)
	{
	super.reset(newProcessor); // clears indent and parameters
	m_stylesheetReady = false;
	if (newProcessor)
	{
	try
	{
	newProcessor(newProcessorOpts);
	}
	catch (Exception e)
	{
	//@todo Hmm: what should we do here?
	}
	}
	}

	/**
	* Apply a single parameter to a Transformer.
	*
	* Overridden for XT to call setParameter().
	*
	* @param passThru to be passed to each applyParameter() method
	* call - for TrAX, you might pass a Transformer object.
	* @param namespace for the parameter, may be null
	* @param name for the parameter, should not be null
	* @param value for the parameter, may be null
	*/
	protected void applyParameter(Object passThru, String namespace,
	String name, Object value)
	{
	try
	{
	XSLProcessorImpl p = (XSLProcessorImpl)passThru;
	//@todo: HACK: smash the namespace in - not sure if this is correct
	if (null != namespace)
	{
	name = namespace + ":" + name;
	}
	p.setParameter(name, value);
	}
	catch (Exception e)
	{
	throw new IllegalArgumentException("applyParameter threw: " + e.toString());
	}
	}

	} // end of class XTWrapper