java/src/org/apache/qetest/xslwrapper/TransformWrapperHelper.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.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Properties;

 /**
  * A few default implementations of TransformWrapper methods.
  *
  * A TransformWrapperHelper implements a few of the common methods
  * from TransformWrapper that don't directly interact with the
  * underlying processor.  Individual wrapper implementations are
  * free to extend this class to get some free code.
  *
  * @author Shane Curcuru
  * @version $Id$
  */
 public abstract class TransformWrapperHelper implements TransformWrapper
 {

     /** Constant denoting that indent should not be set.  */
     protected static final int NO_INDENT = -2;


     /**
      * Current number of spaces to indent, default: NO_INDENT.
      * Users call setAttribute(ATTRIBUTE_INDENT, int) to set this.
      * If it is set, it will be applied to an underlying processor
      * during each transform operation, where supported.
      */
     protected int m_indent = NO_INDENT;


     /**
      * Allows the user to ask the wrapper to set specific
      * attributes on the underlying implementation.
      *
      * Supported attributes in this class include:
      * ATTRIBUTE_INDENT
      *
      * //@todo define behavior for subclasses who want our default
      * behavior but also want to throw the exception for
      * attributes that are not recognized.
      *
      * @param name The name of the attribute.
      * @param value The value of the attribute.
      *
      * @throws IllegalArgumentException thrown only if we can't
      * parse an int from the value
      *
      * @see #ATTRIBUTE_INDENT
      */
     public void setAttribute(String name, Object value)
         throws IllegalArgumentException
     {
         if (ATTRIBUTE_INDENT.equals(name))
         {
             try
             {
                 m_indent = (new Integer((String)value)).intValue();
             }
             catch (Exception e)
             {
                 throw new IllegalArgumentException("setAttribute: bad value: " + value);
             }
         }
     }


     /**
      * Allows the user to set specific attributes on the testing
      * utility or it's underlying product object under test.
      *
      * This method should attempt to set any applicable attributes
      * found in the given attrs onto itself, and will ignore any and
      * all attributes it does not recognize.  It should never
      * throw exceptions.  This method may overwrite any previous
      * attributes that were set.  Currently since this takes a
      * Properties block you may only be able to set objects that
      * are Strings, although individual implementations may
      * attempt to use Hashtable.get() on only the local part.
      *
      * Currently unimplemented; no-op.
      *
      * @param attrs Props of various name, value attrs.
      */
     public void applyAttributes(Properties attrs)
     {
         /* no-op */;
     }


     /**
      * Allows the user to retrieve specific attributes on the
      * underlying implementation.
      *
      * This class merely returns the indent for ATTRIBUTE_INDENT.
      *
      * //@todo define behavior for subclasses who want our default
      * behavior but also want to throw the exception for
      * attributes that are not recognized.
      *
      * @param name The name of the attribute.
      * @return value The value of the attribute.
      * @throws IllegalArgumentException not thrown from this class
      *
      * @see #ATTRIBUTE_INDENT
      */
     public Object getAttribute(String name) throws IllegalArgumentException
     {
         if (ATTRIBUTE_INDENT.equals(name))
         {
             return new Integer(m_indent);
         }
         return null;
     }


     /** If our wrapper has a built stylesheet ready.  */
     protected boolean m_stylesheetReady = false;


     /**
      * Reports if a pre-built/pre-compiled stylesheet is ready;
      * presumably built by calling buildStylesheet(xslName).
      *
      * @return true if one is ready; false otherwise
      *
      * @see #buildStylesheet(String xslName)
      */
     public boolean isStylesheetReady()
     {
         return m_stylesheetReady;
     }


     /** Set of stylesheet parameters for use in transforms.  */
     protected Hashtable m_params = null;


     /**
      * Set a stylesheet parameter for use in later transforms.
      *
      * This method merely stores the triple for use later in a
      * transform operation.  Note that the actual mechanisims for
      * setting parameters in implementation differ, especially with
      * regards to namespaces.
      *
      * Note that the namespace may not contain the "{" or "}"
      * characters, since these would be illegal XML namespaces
      * anyways; an IllegalArgumentException will be thrown.
      * Note that the name may not begin with the "{"
      * character, since it would likely be an illegal XML name
      * anyways; an IllegalArgumentException will be thrown.
      *
      * @param namespace for the parameter
      * @param name of the parameter
      * @param value of the parameter
      *
      * @throws IllegalArgumentException thrown if the namespace
      * appears to be illegal.
      */
     public void setParameter(String namespace, String name, Object value)
         throws IllegalArgumentException
     {
         if (null != namespace)
         {
             if ((namespace.indexOf("{") > -1)
                 || (namespace.indexOf("}") > -1))
                 throw new IllegalArgumentException(
                     "setParameter: illegal namespace includes brackets: " + namespace);
         }
         if (null != name)
         {
             if (name.startsWith("{"))
                 throw new IllegalArgumentException(
                     "setParameter: illegal name begins with bracket: " + name);
         }

         if (null == m_params)
             m_params = new Hashtable();

         if (null != namespace)
         {
             m_params.put("{" + namespace + "}" + name, value);
         }
         else
         {
             m_params.put(name, value);
         }
     }


     /**
      * Get a parameter that was set with setParameter.
      *
      * Only returns parameters set locally, not parameters exposed
      * by the underlying processor implementation.  Not terribly useful
      * but I always like providing gets for any sets I define.
      *
      * @param namespace for the parameter
      * @param name of the parameter
      *
      * @param value of the parameter; null if not found
      */
     public Object getParameter(String namespace, String name)
     {
         if (null == m_params)
             return null;

         if (null != namespace)
         {
             return m_params.get("{" + namespace + "}" + name);
         }
         else
         {
             return m_params.get(name);
         }
     }


     /**
      * Apply the parameters that were set with setParameter to
      * our underlying processor implementation.
      *
      * Subclasses may call this to apply all set parameters during
      * each transform if they override the applyParameter() method
      * to set a single parameter.
      *
      * This is a convenience method for getting data out of
      * m_params that was encoded by our setParameter().
      *
      * @param passThru to be passed to each applyParameter() method
      * call - for TrAX, you might pass a Transformer object.
      */
     protected void applyParameters(Object passThru)
     {
         if (null == m_params)
             return;

         for (Enumeration keys = m_params.keys();
              keys.hasMoreElements();
              /* no increment portion */ )
         {
             String namespace = null;
             String name = null;
             String key = keys.nextElement().toString();
             //@todo compare with TransformerImpl.setParameter's use of a StringTokenizer(..., "{}"...
             // Decode the namespace, if present
             if (key.startsWith("{"))
             {
                 int idx = key.indexOf("}");
                 namespace = key.substring(1, idx);
                 name = key.substring(idx + 1); //@todo check for out of range?
             }
             else
             {
                 // namespace stays null
                 name = key;
             }
             // Call subclassed worker method for each parameter
             applyParameter(passThru, namespace, name, m_params.get(key));
         }
     }


     /**
      * Apply a single parameter to our underlying processor
      * implementation: must be overridden.
      *
      * Subclasses must override; this class will throw an
      * IllegalStateException since we can't do anything.
      *
      * @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)
     {
         throw new IllegalStateException("TransformWrapperHelper.applyParameter must be overridden!");
     }


     /**
      * Reset our parameters and wrapper state, and optionally
      * force creation of a new underlying processor implementation.
      *
      * This class clears the indent and any parameters.
      * Subclasses are free to call us to get this default behavior
      * or not.  Note that subclasses must clear m_stylesheetReady
      * themselves if needed.
      *
      * @param newProcessor ignored in this class
      */
     public void reset(boolean newProcessor)
     {
         m_params = null;
         m_indent = NO_INDENT;
     }


     /**
      * Static worker method to return default array of longs.
      *
      * Simply returns long[] pre-filled to TIME_UNUSED, suitable
      * for returning from various transform API's.  May be called
      * by external callers to get pre-sized array.
      *
      * @return long[] = TIME_UNUSED
      */
     public static long[] getTimeArray()
     {
         return new long[]
         {
             TIME_UNUSED, /* IDX_OVERALL */
             TIME_UNUSED, /* IDX_XSLREAD */
             TIME_UNUSED, /* IDX_XSLBUILD */
             TIME_UNUSED, /* IDX_XMLREAD */
             TIME_UNUSED, /* IDX_XMLBUILD */
             TIME_UNUSED, /* IDX_TRANSFORM */
             TIME_UNUSED, /* IDX_RESULTWRITE */
             TIME_UNUSED  /* IDX_FIRSTLATENCY */
         };
     }


     /**
      * Static worker method to return description of timing slots.
      *
      * @return String describing this idx slot in a getTimeArray
      */
     public static String getTimeArrayDesc(int idx)
     {
         switch (idx)
         {
             case IDX_OVERALL:
                 return "OVERALL";

             case IDX_XSLREAD:
                 return "XSLREAD";

             case IDX_XSLBUILD:
                 return "XSLBUILD";

             case IDX_XMLREAD:
                 return "XMLREAD";

             case IDX_XMLBUILD:
                 return "XMLBUILD";

             case IDX_TRANSFORM:
                 return "TRANSFORM";

             case IDX_RESULTWRITE:
                 return "RESULTWRITE";

             case IDX_FIRSTLATENCY:
                 return "FIRSTLATENCY";

             default:
                 return "ERROR:unknown-getTimeArrayDesc-idx";
         }
     }
 }
	/*
	* 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.util.Enumeration;
	import java.util.Hashtable;
	import java.util.Properties;

	/**
	* A few default implementations of TransformWrapper methods.
	*
	* A TransformWrapperHelper implements a few of the common methods
	* from TransformWrapper that don't directly interact with the
	* underlying processor. Individual wrapper implementations are
	* free to extend this class to get some free code.
	*
	* @author Shane Curcuru
	* @version $Id$
	*/
	public abstract class TransformWrapperHelper implements TransformWrapper
	{

	/** Constant denoting that indent should not be set. */
	protected static final int NO_INDENT = -2;


	/**
	* Current number of spaces to indent, default: NO_INDENT.
	* Users call setAttribute(ATTRIBUTE_INDENT, int) to set this.
	* If it is set, it will be applied to an underlying processor
	* during each transform operation, where supported.
	*/
	protected int m_indent = NO_INDENT;


	/**
	* Allows the user to ask the wrapper to set specific
	* attributes on the underlying implementation.
	*
	* Supported attributes in this class include:
	* ATTRIBUTE_INDENT
	*
	* //@todo define behavior for subclasses who want our default
	* behavior but also want to throw the exception for
	* attributes that are not recognized.
	*
	* @param name The name of the attribute.
	* @param value The value of the attribute.
	*
	* @throws IllegalArgumentException thrown only if we can't
	* parse an int from the value
	*
	* @see #ATTRIBUTE_INDENT
	*/
	public void setAttribute(String name, Object value)
	throws IllegalArgumentException
	{
	if (ATTRIBUTE_INDENT.equals(name))
	{
	try
	{
	m_indent = (new Integer((String)value)).intValue();
	}
	catch (Exception e)
	{
	throw new IllegalArgumentException("setAttribute: bad value: " + value);
	}
	}
	}


	/**
	* Allows the user to set specific attributes on the testing
	* utility or it's underlying product object under test.
	*
	* This method should attempt to set any applicable attributes
	* found in the given attrs onto itself, and will ignore any and
	* all attributes it does not recognize. It should never
	* throw exceptions. This method may overwrite any previous
	* attributes that were set. Currently since this takes a
	* Properties block you may only be able to set objects that
	* are Strings, although individual implementations may
	* attempt to use Hashtable.get() on only the local part.
	*
	* Currently unimplemented; no-op.
	*
	* @param attrs Props of various name, value attrs.
	*/
	public void applyAttributes(Properties attrs)
	{
	/* no-op */;
	}


	/**
	* Allows the user to retrieve specific attributes on the
	* underlying implementation.
	*
	* This class merely returns the indent for ATTRIBUTE_INDENT.
	*
	* //@todo define behavior for subclasses who want our default
	* behavior but also want to throw the exception for
	* attributes that are not recognized.
	*
	* @param name The name of the attribute.
	* @return value The value of the attribute.
	* @throws IllegalArgumentException not thrown from this class
	*
	* @see #ATTRIBUTE_INDENT
	*/
	public Object getAttribute(String name) throws IllegalArgumentException
	{
	if (ATTRIBUTE_INDENT.equals(name))
	{
	return new Integer(m_indent);
	}
	return null;
	}


	/** If our wrapper has a built stylesheet ready. */
	protected boolean m_stylesheetReady = false;


	/**
	* Reports if a pre-built/pre-compiled stylesheet is ready;
	* presumably built by calling buildStylesheet(xslName).
	*
	* @return true if one is ready; false otherwise
	*
	* @see #buildStylesheet(String xslName)
	*/
	public boolean isStylesheetReady()
	{
	return m_stylesheetReady;
	}


	/** Set of stylesheet parameters for use in transforms. */
	protected Hashtable m_params = null;


	/**
	* Set a stylesheet parameter for use in later transforms.
	*
	* This method merely stores the triple for use later in a
	* transform operation. Note that the actual mechanisims for
	* setting parameters in implementation differ, especially with
	* regards to namespaces.
	*
	* Note that the namespace may not contain the "{" or "}"
	* characters, since these would be illegal XML namespaces
	* anyways; an IllegalArgumentException will be thrown.
	* Note that the name may not begin with the "{"
	* character, since it would likely be an illegal XML name
	* anyways; an IllegalArgumentException will be thrown.
	*
	* @param namespace for the parameter
	* @param name of the parameter
	* @param value of the parameter
	*
	* @throws IllegalArgumentException thrown if the namespace
	* appears to be illegal.
	*/
	public void setParameter(String namespace, String name, Object value)
	throws IllegalArgumentException
	{
	if (null != namespace)
	{
	if ((namespace.indexOf("{") > -1)
	\|\| (namespace.indexOf("}") > -1))
	throw new IllegalArgumentException(
	"setParameter: illegal namespace includes brackets: " + namespace);
	}
	if (null != name)
	{
	if (name.startsWith("{"))
	throw new IllegalArgumentException(
	"setParameter: illegal name begins with bracket: " + name);
	}

	if (null == m_params)
	m_params = new Hashtable();

	if (null != namespace)
	{
	m_params.put("{" + namespace + "}" + name, value);
	}
	else
	{
	m_params.put(name, value);
	}
	}


	/**
	* Get a parameter that was set with setParameter.
	*
	* Only returns parameters set locally, not parameters exposed
	* by the underlying processor implementation. Not terribly useful
	* but I always like providing gets for any sets I define.
	*
	* @param namespace for the parameter
	* @param name of the parameter
	*
	* @param value of the parameter; null if not found
	*/
	public Object getParameter(String namespace, String name)
	{
	if (null == m_params)
	return null;

	if (null != namespace)
	{
	return m_params.get("{" + namespace + "}" + name);
	}
	else
	{
	return m_params.get(name);
	}
	}


	/**
	* Apply the parameters that were set with setParameter to
	* our underlying processor implementation.
	*
	* Subclasses may call this to apply all set parameters during
	* each transform if they override the applyParameter() method
	* to set a single parameter.
	*
	* This is a convenience method for getting data out of
	* m_params that was encoded by our setParameter().
	*
	* @param passThru to be passed to each applyParameter() method
	* call - for TrAX, you might pass a Transformer object.
	*/
	protected void applyParameters(Object passThru)
	{
	if (null == m_params)
	return;

	for (Enumeration keys = m_params.keys();
	keys.hasMoreElements();
	/* no increment portion */ )
	{
	String namespace = null;
	String name = null;
	String key = keys.nextElement().toString();
	//@todo compare with TransformerImpl.setParameter's use of a StringTokenizer(..., "{}"...
	// Decode the namespace, if present
	if (key.startsWith("{"))
	{
	int idx = key.indexOf("}");
	namespace = key.substring(1, idx);
	name = key.substring(idx + 1); //@todo check for out of range?
	}
	else
	{
	// namespace stays null
	name = key;
	}
	// Call subclassed worker method for each parameter
	applyParameter(passThru, namespace, name, m_params.get(key));
	}
	}


	/**
	* Apply a single parameter to our underlying processor
	* implementation: must be overridden.
	*
	* Subclasses must override; this class will throw an
	* IllegalStateException since we can't do anything.
	*
	* @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)
	{
	throw new IllegalStateException("TransformWrapperHelper.applyParameter must be overridden!");
	}


	/**
	* Reset our parameters and wrapper state, and optionally
	* force creation of a new underlying processor implementation.
	*
	* This class clears the indent and any parameters.
	* Subclasses are free to call us to get this default behavior
	* or not. Note that subclasses must clear m_stylesheetReady
	* themselves if needed.
	*
	* @param newProcessor ignored in this class
	*/
	public void reset(boolean newProcessor)
	{
	m_params = null;
	m_indent = NO_INDENT;
	}


	/**
	* Static worker method to return default array of longs.
	*
	* Simply returns long[] pre-filled to TIME_UNUSED, suitable
	* for returning from various transform API's. May be called
	* by external callers to get pre-sized array.
	*
	* @return long[] = TIME_UNUSED
	*/
	public static long[] getTimeArray()
	{
	return new long[]
	{
	TIME_UNUSED, /* IDX_OVERALL */
	TIME_UNUSED, /* IDX_XSLREAD */
	TIME_UNUSED, /* IDX_XSLBUILD */
	TIME_UNUSED, /* IDX_XMLREAD */
	TIME_UNUSED, /* IDX_XMLBUILD */
	TIME_UNUSED, /* IDX_TRANSFORM */
	TIME_UNUSED, /* IDX_RESULTWRITE */
	TIME_UNUSED /* IDX_FIRSTLATENCY */
	};
	}


	/**
	* Static worker method to return description of timing slots.
	*
	* @return String describing this idx slot in a getTimeArray
	*/
	public static String getTimeArrayDesc(int idx)
	{
	switch (idx)
	{
	case IDX_OVERALL:
	return "OVERALL";

	case IDX_XSLREAD:
	return "XSLREAD";

	case IDX_XSLBUILD:
	return "XSLBUILD";

	case IDX_XMLREAD:
	return "XMLREAD";

	case IDX_XMLBUILD:
	return "XMLBUILD";

	case IDX_TRANSFORM:
	return "TRANSFORM";

	case IDX_RESULTWRITE:
	return "RESULTWRITE";

	case IDX_FIRSTLATENCY:
	return "FIRSTLATENCY";

	default:
	return "ERROR:unknown-getTimeArrayDesc-idx";
	}
	}
	}