/*
 * 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.
 */

#if !defined(XALANTRANSFORMER_HEADER_GUARD)
#define XALANTRANSFORMER_HEADER_GUARD

// Base include file.  Must be first.
#include <xalanc/XalanTransformer/XalanTransformerDefinitions.hpp>


#include <cassert>
#include <iosfwd>
#include <algorithm>


#include <xalanc/Include/XalanVector.hpp>

#include <xalanc/XalanDOM/XalanNode.hpp>
#include <xalanc/Include/XalanMap.hpp>
#include <xalanc/XSLT/XalanParamHolder.hpp>
#include <xalanc/XPath/XObjectFactoryDefault.hpp>

#include <xalanc/XPath/XalanQNameByValue.hpp>


#include <xalanc/XSLT/XSLTInputSource.hpp>
#include <xalanc/XSLT/XSLTResultTarget.hpp>


namespace XERCES_CPP_NAMESPACE
{
    class EntityResolver;
    class ErrorHandler;
    class XMLEntityResolver;
}


namespace XALAN_CPP_NAMESPACE {


typedef xercesc::EntityResolver   EntityResolverType;
typedef xercesc::ErrorHandler     ErrorHandlerType;

using xercesc::EntityResolver;
using xercesc::ErrorHandler;
using xercesc::XMLEntityResolver;


class Function;
class StylesheetExecutionContextDefault;
class ProblemListener;
class TraceListener;
class XSLTInit;
class XalanDocumentBuilder;
class XalanCompiledStylesheet;
class XalanParsedSource;
class XalanTransformerOutputStream;

class XObjectFactoryDefault;
class XalanNode;

/**
 * This is a simple C++ interface for some common usage patterns. It's 
 * the user's responsibility to call initialize and terminate for Xerces 
 * and Xalan before creating and after deleting any XalanTransformer  
 * instances.
*/
class XALAN_TRANSFORMER_EXPORT XalanTransformer
{

public:
    
    typedef std::ostream    StreamType;

    typedef XalanVector<const XalanCompiledStylesheet*> CompiledStylesheetPtrVectorType;
    typedef XalanVector<const XalanParsedSource*>       ParsedSourcePtrVectorType;

    typedef XalanMap<XalanDOMString, XalanParamHolder>    ParamMapType;

    typedef XalanMap<XalanQNameByValue, Function*>  FunctionMapType;
    typedef XalanVector<TraceListener*>             TraceListenerVectorType;

    XalanTransformer(MemoryManager&     theManager = XalanMemMgrs::getDefaultXercesMemMgr());

    virtual
    ~XalanTransformer();

    MemoryManager&
    getMemoryManager()
    {
        return m_memoryManager;
    }

    const MemoryManager& 
    getMemoryManager() const
    {
        return m_memoryManager;
    }

    /**
     * Initialize Xalan.
     *
     * Should be called only once per process before creating any
     * instances of XalanTransformer.  This call is not thread-safe,
     * so you must serialize any calls to it, and you must track the
     * initialization state, so you do not call it more than once.
     */
    static void
    initialize(MemoryManager&   theManager = XalanMemMgrs::getDefaultXercesMemMgr());

    /**
     * Terminate Xalan.
     *
     * Should be called only once per process after deleting all
     * instances of XalanTransformer.  This call is not thread-safe,
     * so you must serialize any calls to it, and you must track the
     * initialization state, so you do not call it more than once.
     *
     * This is handy when using leak-detection software, as all
     * static data allocated by Xalan is freed.
     *
     */
    static void
    terminate();

    /**
     * Clean up the ICU, if ICU integration is enabled.
     *
     * This should be called only once per process after calling
     * XalanTransformer::terminate() and XMLPlatformUtils::Terminate.
     *
     * This must only be done if the ICU will no longer be used by
     * the process, since the ICU will no longer be in a usable state.
     * See the ICU documentation for more details.
     *
     * This call is not thread-safe, so you must serialize any calls
     * to it, and you must track the initialization state, so you do
     * not call it more than once.
     *
     * This is handy when using leak-detection software, as all
     * static data allocated by the ICU is freed.
     *
     */
    static void
    ICUCleanUp();


    static void
    ICUStartUp(MemoryManager&   theManager = XalanMemMgrs::getDefaultXercesMemMgr());

    /**
     * Transform will apply the stylesheet source to the parsed xml source
     * and write the transformation output to the target. 
     *
     * @param theParsedXML          the parsed input source
     * @param theStylesheetSource   stylesheet source
     * @param theResultTarget       output source
     * @return  0 for success
     */
    int
    transform(
            const XalanParsedSource&    theParsedXML, 
            const XSLTInputSource&      theStylesheetSource,
            const XSLTResultTarget&     theResultTarget)
    {
        return doTransform(theParsedXML, 0, &theStylesheetSource, theResultTarget);
    }

    /**
     * Transform will apply the compiled stylesheet to the parsed xml source
     * and write the transformation output to the target. 
     *
     * @param theParsedXML          the parsed input source
     * @param theCompiledStylesheet pointer to a compiled stylesheet.  Must not be null.
     * @param theResultTarget       output source 
     * @return  0 for success
     */
    int
    transform(
            const XalanParsedSource&        theParsedXML,
            const XalanCompiledStylesheet*  theCompiledStylesheet,
            const XSLTResultTarget&         theResultTarget)
    {
        assert(theCompiledStylesheet != 0);

        return doTransform(theParsedXML, theCompiledStylesheet, 0, theResultTarget);
    }

    /**
     * Transform will apply the stylesheet provided as a PI in the 
     * XML of the parsed xml source and write the transformation output to 
     * the target. 
     *
     * @param theParsedXML      the parsed input source
     * @param theResultTarget   output source tree
     * @return                  0 for success
     */
    int
    transform(
            const XalanParsedSource&    theParsedXML,                
            const XSLTResultTarget&     theResultTarget)
    {
        assert(s_emptyInputSource != 0);

        return transform(theParsedXML, *s_emptyInputSource, theResultTarget);
    }

    /**
     * Transform will apply the stylesheet source to the input source
     * and write the transformation output to the target. The input 
     * source and result target can be a file name, a stream or a root
     * node.
     *
     * @param theInputSource        input source
     * @param theStylesheetSource   stylesheet source
     * @param theResultTarget       output source
     * @return  0 for success
     */
    int
    transform(
            const XSLTInputSource&      theInputSource,
            const XSLTInputSource&      theStylesheetSource,
            const XSLTResultTarget&     theResultTarget);

    /**
     * Transform will apply the stylesheet provided as a PI in the 
     * XML of the input source and write the transformation output to 
     * the target. The input source and result target can be a file 
     * name, a stream or a root node.
     *
     * @param theInputSource        input source
     * @param theResultTarget       output source tree
     * @return  0 for success
     */
    int
    transform(
            const XSLTInputSource&      theInputSource,
            const XSLTResultTarget&     theResultTarget)
    {
        assert(s_emptyInputSource != 0);

        return transform(
                        theInputSource, 
                        *s_emptyInputSource,
                        theResultTarget);
    }

    /**
     * Transform will apply the stylesheet source to the input source
     * and write the transformation result to a callback function  
     * in pre-allocated blocks. The input source can be a file name, 
     * a stream or a root node. Upon termination, Xalan releases any 
     * allocated memory. Data passed to the callback is not guaranteed to 
     * be null terminated.
     *
     * - See XalanTransformerOutputStream and XalanOutputHandlerType 
     * for more details.
     * 
     * @param theInputSource        input source
     * @param theStylesheetSource   stylesheet source   
     * @param theOutputHandle       void pointer passed through to callback.
     * @param theOutputHandler      a user defined (callback) function.
     * @param theFlushHandler       (optional) a user defined (callback) function.
     * @return  0 for success 
     */
    int
    transform(
            const XSLTInputSource&      theInputSource, 
            const XSLTInputSource&      theStylesheetSource,
            void*                       theOutputHandle, 
            XalanOutputHandlerType      theOutputHandler,
            XalanFlushHandlerType       theFlushHandler = 0);
    
    /**
     * Transform will apply the compiled stylesheet to the input source
     * and write the transformation output to the target. The input 
     * source and result target can be a file name, a stream or a root
     * node. 
     *
     * @param theInputSource        input source
     * @param theCompiledStylesheet pointer to a compiled stylesheet.  Must not be null.
     * @param theResultTarget       output source 
     * @return  0 for success
     */
    int
    transform(
            const XSLTInputSource&          theInputSource, 
            const XalanCompiledStylesheet*  theCompiledStylesheet,
            const XSLTResultTarget&         theResultTarget);
 
    /**
     * Transform will apply the compiled stylesheet to the source
     * and write the transformation result to a callback function  
     * in pre-allocated blocks. The input source can be a file name, 
     * a stream or a root node. Upon termination, Xalan releases any 
     * allocated memory. Data passed to the callback is not guaranteed to 
     * be null terminated.
     *
     * - See XalanTransformerOutputStream and XalanOutputHandlerType 
     * for more details.
     * 
     * @param theParsedSource       Parsed source instance
     * @param theCompiledStylesheet pointer to a compiled stylesheet.  Must not be null.
     * @param theOutputHandle       void pointer passed through to callback.
     * @param theOutputHandler      a user defined callback function.
     * @param theFlushHandler       An optional user-defined callback function.
     * @return  0 for success 
     */
    int
    transform(
            const XalanParsedSource&        theParsedSource,
            const XalanCompiledStylesheet*  theCompiledStylesheet,
            void*                           theOutputHandle,
            XalanOutputHandlerType          theOutputHandler,
            XalanFlushHandlerType           theFlushHandler = 0);

    /**
     * Transform will apply the stylesheet provided as a PI in the 
     * XML of the input source and write  the transformation result to a  
     * callback function in pre-allocated blocks. The input source can be 
     * a file name, a stream or a root node. Upon termination, Xalan 
     * releases any allocated memory. Data passed to the callback is not 
     * guaranteed to be null terminated.
     *
     * - See XalanTransformerOutputStream and XalanOutputHandlerType 
     * for more details.
     * 
     * @param theInputSource        input source
     * @param theOutputHandle       void pointer passed through to callback.
     * @param theOutputHandler      a user defined callback function.
     * @param theFlushHandler       an optional user-defined callback function.
     * @return  0 for success 
     */
    int
    transform(
            const XSLTInputSource&      theInputSource,
            void*                       theOutputHandle,
            XalanOutputHandlerType      theOutputHandler,
            XalanFlushHandlerType       theFlushHandler = 0);

    /**
     * Creates a compiled stylesheet.  The input source can be 
     * a file name, a stream or a root node.   The XalanTransformer
     * instance owns the XalanCompiledStylesheet instance and will
     * delete it when the XalanTransformer instance goes out of scope,
     * or you explicitly call destroyStylesheet().  You must not delete
     * the instance yourself.
     *
     * @param theStylesheetSource input source
     * @param theCompiledStylesheet a reference to a pointer to a XalanCompileStylesheet.
     * @return 0 for success 
     */
    int
    compileStylesheet(
            const XSLTInputSource&              theStylesheetSource,
            const XalanCompiledStylesheet*&     theCompiledStylesheet);

    /**
     * Destroy a XalanCompiledStylesheet instance created by a previous
     * call to compileStylesheet().
     *
     * @param theStylesheet The instance to destroy.
     * @return 0 for success 
     */
    int
    destroyStylesheet(const XalanCompiledStylesheet*    theStylesheet);

    /**
     * Parse a source XML document.  The input source can be 
     * a file name, a stream or a root node.  The XalanTransformer
     * instance owns the XalanParsedSource instance and will
     * delete it when the XalanTransformer instance goes out of scope,
     * or you explicitly call destroyParsedSource().  You must not
     * delete the instance yourself.
     *
     * @param theInputSource input source
     * @param theParsedSource a reference to a pointer to a XalanParsedSource.
     * @param useXercesDOM input use default or xerces DOM source tree
     * @return 0 for success 
     */
    int
    parseSource(
            const XSLTInputSource&      theInputSource,
            const XalanParsedSource*&   theParsedSource,
            bool                        useXercesDOM = false);

    /**
     * Destroy a parsed source created by a previous call to parseSource().
     *
     * @param theParsedSource The XalanParsedSource instance to destroy.
     * @return 0 for success 
     */
    int
    destroyParsedSource(const XalanParsedSource*    theParsedSource);

    /**
     * Create a document builder.  Using the document builder, you
     * can construct a document using SAX2 interfaces.  The XalanTransformer
     * instance owns the document builder and will delete it when the
     * XalanTransformer instance goes out of scope, or you explicitly call
     * destroyDocumentBuilder().  You must not delete the instance yourself.
     *
     * @param theURI The base URI for the document instance.
     * @return  a pointer to a XalanDocumentBuilder instance or 0 for failure.
     */
    XalanDocumentBuilder*
    createDocumentBuilder(const XalanDOMString&     theURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()));

    /**
     * Destroy a document builder created by a previous call to createDocumentBuilder().
     * Passing a pointer that is not created by a call to createDocumentBuilder() can
     * result in undefined behavior.
     *
     * @param theDocumentBuilder The document builder to destroy.
     */
    void
    destroyDocumentBuilder(XalanDocumentBuilder*    theDocumentBuilder);

    /**
     * Install an external function in the local space.
     *
     * @param theNamespace The namespace for the functionl
     * @param functionName The name of the function.
     * @param function The function to install.
     */
    void
    installExternalFunction(
            const XalanDOMString&   theNamespace,
            const XalanDOMString&   functionName,
            const Function&         function);

    /**
     * Install an external function in the global space.
     *
     * @param theNamespace The namespace for the functionl
     * @param functionName The name of the function.
     * @param function The function to install.
     */
    static void
    installExternalFunctionGlobal(
            const XalanDOMString&   theNamespace,
            const XalanDOMString&   functionName,
            const Function&         function);

    /**
     * Uninstall an external local function.
     *
     * @param theNamespace The namespace for the function
     * @param functionName The name of the function.
     */
    void
    uninstallExternalFunction(
            const XalanDOMString&   theNamespace,
            const XalanDOMString&   functionName);

    /**
     * Uninstall an external global function.
     *
     * @param theNamespace The namespace for the function
     * @param functionName The name of the function.
     */
    static void
    uninstallExternalFunctionGlobal(
            const XalanDOMString&   theNamespace,
            const XalanDOMString&   functionName);

    /**
     * Retrieve the factory object for creating XObjects.
     * 
     * @return factory object instance
     */
    XObjectFactory&
    getXObjectFactory() const
    {
        assert(m_topXObjectFactory != 0);

        return *m_topXObjectFactory;
    }

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param expression expression that will be evaluated
     */
    void
    setStylesheetParam(
            const XalanDOMString&   key,
            const XalanDOMString&   expression);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param expression expression that will be evaluated
     */
    void
    setStylesheetParam(
            const char*     key,
            const char*     expression);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param number value to be evaluated
     */
    void
    setStylesheetParam(
            const char*     key,
            double          number);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param number value to be evaluated
     */
    void
    setStylesheetParam(
            const XalanDOMString&       key,
            double                      number);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param nodeset XML nodeset that will be evaulated
     */
    void
    setStylesheetParam(
            const char*               key,
            XalanNode*          nodeset);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param nodeset XML nodeset that will be evaluated
     */
    void
    setStylesheetParam(
            const XalanDOMString&     key,
            XalanNode*          nodeset);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param object any XObject owned by the transformer
     */
    void
    setStylesheetParam(
            const char*               key,
            XObjectPtr                object);

    /**
     * Set a top-level parameter, which the stylesheet can access
     * with a top-level xsl:param.  Top-level params are "sticky,"
     * and must be removed with a call to clearStylesheetParams().
     *
     * @param key name of the param
     * @param object any XObject owned by the transformer
     */
    void
    setStylesheetParam(
            const XalanDOMString&     key,
            XObjectPtr                object);

    /**
     * Clear any stylesheet params.
     */
    void
    clearStylesheetParams()
    {
        m_params.clear();
        m_topXObjectFactory->reset();
    }

    /**
     * Add a TraceListener instance.  TraceListeners instances are preserved
     * between calls to transform(), so they will be called until they are
     * removed.
     *
     * @param theTraceListener The instance to add.
     */
    void
    addTraceListener(TraceListener*     theTraceListener)
    {
        m_traceListeners.push_back(theTraceListener);
    }

    /**
     * Remove a TraceListener instance
     *
     * @param theTraceListener The instance to remove.
     * @return true if the instance was removed, false if not.
     */
    bool
    removeTraceListener(TraceListener*  theTraceListener);

    /**
     * Remove all TraceListener instances.
     */
    void
    removeTraceListeners()
    {
        m_traceListeners.clear();
    }

    /**
     * Set a flag to indicate whether or not the source file(s) for the
     * transformation will be validated.
     *
     * @param fValue the new value for the flag.
     */
    bool
    getUseValidation() const
    {
        return m_useValidation;
    }

    /**
     * Set a flag to indicate whether or not the source file(s) for the
     * transformation will be validated.
     *
     * @param fValue the new value for the flag.
     */
    void
    setUseValidation(bool   fValue)
    {
        m_useValidation = fValue;
    }

    /**
     * Returns the installed EntityResolver.
     *
     * @return The pointer to the installed EntityResolver.
     */
    EntityResolver*
    getEntityResolver() const
    {
        return m_entityResolver;
    }

    /**
     * Installs the supplied EntityResolver.
     *
      * A call to setEntityResolver with a non-null pointer will
      * uninstall any XMLEntityResolver previously installed.
      *
     * @param theResolver A pointer to the EntityResolver.
     */
    void
    setEntityResolver(EntityResolver*   theResolver)
    {
        m_entityResolver = theResolver;

        if (theResolver != 0 && m_xmlEntityResolver != 0)
        {
            m_xmlEntityResolver = 0;
        }
    }

    /**
     * Returns the installed XMLEntityResolver.
     *
     * @return The pointer to the installed XMLEntityResolver.
     */
    XMLEntityResolver*
    getXMLEntityResolver() const
    {
        return m_xmlEntityResolver;
    }

    /**
     * Installs the supplied XMLEntityResolver.
     *
      * A call to setXMLEntityResolver with a non-null pointer will
      * uninstall any EntityResolver previously installed.
      *
     * @param theResolver A pointer to the XMLEntityResolver.
     */
    void
    setXMLEntityResolver(XMLEntityResolver*     theResolver)
    {
        m_xmlEntityResolver = theResolver;

        if (theResolver != 0 && m_entityResolver != 0)
        {
            m_entityResolver = 0;
        }
    }

    /**
     * This method returns the installed error handler.
     *
     * @return The pointer to the installed error handler object.
     */
    ErrorHandler*
    getErrorHandler() const
    {
        return m_errorHandler;
    }

    /**
     * This method installs the user-specified error handler.
     *
     * @param handler A pointer to the error handler to be called upon error.
     */
    void
    setErrorHandler(ErrorHandler*   theErrorHandler)
    {
        m_errorHandler = theErrorHandler;
    }

    /**
      * This method returns the location for an external schema document
      * for parsing.
      *
      * @return A string representing the location of the external schema document
      */
    const XalanDOMChar*
    getExternalSchemaLocation() const
    {
        return m_externalSchemaLocation.empty() == true ? 0 : m_externalSchemaLocation.c_str();
    }

    /**
      * This method sets the location for an external schema document
      * for parsing.
      *
      * @param location A string representing the location of the external schema document
      */
    void
    setExternalSchemaLocation(const XalanDOMChar*   location)
    {
        assert(location != 0);

        m_externalSchemaLocation = location;
    }

    /**
      * This method returns the location for an external schema document
      * for parsing.
      *
      * @return A string representing the location of the external schema document
      */
    const XalanDOMChar*
    getExternalNoNamespaceSchemaLocation() const
    {
        return m_externalNoNamespaceSchemaLocation.empty() == true ? 0 : m_externalNoNamespaceSchemaLocation.c_str();
    }

    /**
      * This method sets the location for an external schema document
      * for parsing.
      *
      * @param location A string representing the location of the external schema document
      */
    void
    setExternalNoNamespaceSchemaLocation(const XalanDOMChar*    location)
    {
        assert(location != 0);

        m_externalNoNamespaceSchemaLocation = location;
    }

    /**
      * This member functions gets the flag to determine of a default parsed source
      * tree will pool the values of all of the text nodes in the XML document.
      *
      * @return The boolean value for the flag.
      */
    bool
    getPoolAllTextNodes() const
    {
        return m_poolAllTextNodes;
    }

    /**
      * This member functions sets the flag to determine of a default parsed source
      * tree will pool the values of all of the text nodes in the XML document.  This
      * can result in significant memory savings if there are lots of repeated values
      * in text nodes.
      *
      * @param fPool The boolean value for the flag.
      */
    void
    setPoolAllTextNodes(bool    fPool)
    {
        m_poolAllTextNodes = fPool;
    }

    /**
     * This method returns the installed ProblemListener instance.
     *
     * @return The pointer to the installed ProblemListener instance.
     */
    ProblemListener*
    getProblemListener() const
    {
        return  m_problemListener;
    }

    /**
     * This method installs the user-specified ProblemListener instance.
     *
     * @param handler A pointer to the ProblemListener to be called when a problem occurs.
     */
    void
    setProblemListener(ProblemListener*     theProblemListener)
    {
        m_problemListener = theProblemListener;
    }

    /**
     * Returns the last error that occurred as a 
     * result of calling transform. 
     *
     * @return  error message const character pointer.
     */
    const char*
    getLastError() const
    {
        assert(m_errorMessage.empty() == false);

        return &m_errorMessage[0]; 
    }

    /**
     * Get the current output encoding, if any.  Note this is not the output encoding
     * specified in a stylesheet.  Rather, it can override that encoding, if the
     *
     * @return A string containing the current encoding
     */
    const XalanDOMString&
    getOutputEncoding() const
    {
        return m_outputEncoding;
    }

    /**
     * Set the current output encoding.  Note this will override the encoding
     * specified in the stylesheet, if the encoding is available.  However,
     * it will not override any encoding specified by an XSLTResultTarget
     * parameter to one of the transform() member functions.
     *
     * @param theEncoding The encoding to use.
     */
    void
    setOutputEncoding(const XalanDOMString&     theEncoding)
    {
        m_outputEncoding = theEncoding;
    }

    /**
     * Get the current number of spaces to indent.
     * 
     * @return number of spaces
     */
    int
    getIndent() const;

    /**
     * Set the current number of spaces to indent.
     * 
     * @param indentAmount The number of spaces to indent.  Use -1 for the default amount.
     */
    void
    setIndent(int   indentAmount);

    /**
     * Enums to determine whether or not run-time escaping of URLs has been set.
     */
    enum eEscapeURLs
    {
        eEscapeURLsDefault,     // Use the value in the stylesheet
        eEscapeURLsNo,          // Don't escape URLs
        eEscapeURLsYes          // Escape URLs
    };

    /**
     * Get the value for run-time escaping of URLs.  This can
     * override the property specified by the stylesheet.  The
     * default behavior is to honor the property in the stylesheet.
     *
     * @return The value of the enum
     */
    eEscapeURLs
    getEscapeURLs() const;

    /**
     * Set the value for run-time escaping of URLs.  This can
     * override the property specified by the stylesheet.  The
     * default behavior is to honor the property in the stylesheet.
     *
     * @param value The value of the enum
     */
    void
    setEscapeURLs(eEscapeURLs   value);

    /**
     * Enums to determine whether or not run-time omission of the META tag has been set.
     * Relevant only for HTML output
     */
    enum eOmitMETATag
    {
        eOmitMETATagDefault,    // Use the value in the stylesheet
        eOmitMETATagNo,         // Don't omit the META tag
        eOmitMETATagYes         // Omit the META tag
    };

    /**
     * Get the value for run-time omission of the META tag.  This can
     * override the property specified by the stylesheet.  The
     * default behavior is to honor the property in the stylesheet.
     *
     * @return The value of the enum
     */
    eOmitMETATag
    getOmitMETATag() const;

    /**
     * Get the value for run-time omission of the META tag.  This can
     * override the property specified by the stylesheet.  The
     * default behavior is to honor the property in the stylesheet.
     *
     * @param value The value of the enum
     */
    void
    setOmitMETATag(eOmitMETATag     value);

    /**
     * Set the ostream instance for reporting errors.  The default
     * is a null pointer, so errors are not reported.  If there is 
     * a user-installed ProblemListener instance, this is not used, as
     * all such warnings and messages are handled by the that
     * ProblemListener.
     *
     * @param theStream A pointer to the ostream instance.
     */
    void
    setErrorStream(StreamType*  theStream)
    {
        m_errorStream = theStream;
    }

    /**
     * Get the current error stream ostream instance.
     *
     * @return A pointer to the instance.  Can be a null pointer.
     */
    StreamType*
    getErrorStream() const
    {
        return m_errorStream;
    }

    /**
     * Set the ostream instance for reporting warnings and messages.  The default
     * is std::cerr.  If set to a null pointer, no warnings or messages are written.
     * If there is a user-installed ProblemListener instance, this is not used, as
     * all such warnings and messages are handled by the that ProblemListener.
     *
     * @param theStream A pointer to the ostream instance.
     */
    void
    setWarningStream(StreamType*    theStream)
    {
        m_warningStream = theStream;
    }

    /**
     * Get the current warning stream ostream instance.
     *
     * @return A pointer to the instance.  Can be a null pointer.
     */
    StreamType*
    getWarningStream() const
    {
        return m_warningStream;
    }

    bool
    getICUAvailable() const;

    class EnsureFunctionsInstallation
    {
    public:

        EnsureFunctionsInstallation(MemoryManager&  theManager) : 
            m_memoryManagement(theManager),
            m_release(false)
        {    
        }

        ~EnsureFunctionsInstallation();

        void
        install();

        void
        release()
        {
            m_release = true;
        }

    private:

        MemoryManager&  m_memoryManagement;

        bool            m_release;
    };

    class EnsureDestroyParsedSource
    {
    public:

        EnsureDestroyParsedSource(
                XalanTransformer&           theTransformer,
                const XalanParsedSource*    theParsedSource) :
            m_transformer(theTransformer),
            m_parsedSource(theParsedSource)
        {
        }

        ~EnsureDestroyParsedSource()
        {
            m_transformer.destroyParsedSource(m_parsedSource);
        }

    private:

        XalanTransformer&               m_transformer;

        const XalanParsedSource* const  m_parsedSource;
    };

    class EnsureDestroyCompiledStylesheet
    {
    public:

        EnsureDestroyCompiledStylesheet(
                XalanTransformer&               theTransformer,
                const XalanCompiledStylesheet*  theCompiledStylesheet) :
            m_transformer(theTransformer),
            m_compiledStylesheet(theCompiledStylesheet)
        {
        }

        ~EnsureDestroyCompiledStylesheet()
        {
            m_transformer.destroyStylesheet(m_compiledStylesheet);
        }

    private:

        XalanTransformer&                       m_transformer;

        const XalanCompiledStylesheet* const    m_compiledStylesheet;
    };

    struct EnsureDestroyDocumentBuilder
    {
        EnsureDestroyDocumentBuilder(
                XalanTransformer&       theTransformer,
                XalanDocumentBuilder*   theDocumentBuilder) :
            m_transformer(theTransformer),
            m_documentBuilder(theDocumentBuilder)
        {
        }

        ~EnsureDestroyDocumentBuilder()
        {
            m_transformer.destroyDocumentBuilder(m_documentBuilder);
        }

    private:

        XalanTransformer&           m_transformer;

        XalanDocumentBuilder* const m_documentBuilder;
    };

protected:

private:

    void
    reset();

    class EnsureReset
    {
    public:

        EnsureReset(XalanTransformer&   theTransformer) :
            m_transformer(theTransformer)
        {
        }

        ~EnsureReset();

    private:

        XalanTransformer&   m_transformer;
    };

    friend class EnsureReset;

    int
    doTransform(
            const XalanParsedSource&        theParsedXML, 
            const XalanCompiledStylesheet*  theCompiledStylesheet,
            const XSLTInputSource*          theStylesheetSource,
            const XSLTResultTarget&         theResultTarget);


    // Data members...
    MemoryManager&                          m_memoryManager;

    CompiledStylesheetPtrVectorType         m_compiledStylesheets;

    ParsedSourcePtrVectorType               m_parsedSources;

    ParamMapType                            m_params;

    FunctionMapType                         m_functions;

    TraceListenerVectorType                 m_traceListeners;

    CharVectorType                          m_errorMessage;

    bool                                    m_useValidation;

    EntityResolver*                         m_entityResolver;

    XMLEntityResolver*                      m_xmlEntityResolver;

    ErrorHandler*                           m_errorHandler;

    XalanDOMString                          m_externalSchemaLocation;

    XalanDOMString                          m_externalNoNamespaceSchemaLocation;

    ProblemListener*                        m_problemListener;

    StreamType*                             m_errorStream;

    StreamType*                             m_warningStream;

    XalanDOMString                          m_outputEncoding;

    bool                                    m_poolAllTextNodes;

    XObjectFactoryDefault*                  m_topXObjectFactory;

    // This should always be the latest data member!!!
    StylesheetExecutionContextDefault*      m_stylesheetExecutionContext;

    static const XSLTInputSource*           s_emptyInputSource;

    static const XSLTInit*                  s_xsltInit;
};


}


#endif  // XALANTRANSFORMER_HEADER_GUARD