Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.5

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

XalanTransformer.hpp

Go to the documentation of this file.
00001 /*
00002  * The Apache Software License, Version 1.1
00003  *
00004  *
00005  * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights 
00006  * reserved.
00007  *
00008  * Redistribution and use in source and binary forms, with or without
00009  * modification, are permitted provided that the following conditions
00010  * are met:
00011  *
00012  * 1. Redistributions of source code must retain the above copyright
00013  *    notice, this list of conditions and the following disclaimer. 
00014  *
00015  * 2. Redistributions in binary form must reproduce the above copyright
00016  *    notice, this list of conditions and the following disclaimer in
00017  *    the documentation and/or other materials provided with the
00018  *    distribution.
00019  *
00020  * 3. The end-user documentation included with the redistribution,
00021  *    if any, must include the following acknowledgment:  
00022  *       "This product includes software developed by the
00023  *        Apache Software Foundation (http://www.apache.org/)."
00024  *    Alternately, this acknowledgment may appear in the software itself,
00025  *    if and wherever such third-party acknowledgments normally appear.
00026  *
00027  * 4. The names "Xalan" and "Apache Software Foundation" must
00028  *    not be used to endorse or promote products derived from this
00029  *    software without prior written permission. For written 
00030  *    permission, please contact apache@apache.org.
00031  *
00032  * 5. Products derived from this software may not be called "Apache",
00033  *    nor may "Apache" appear in their name, without prior written
00034  *    permission of the Apache Software Foundation.
00035  *
00036  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
00037  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00038  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00039  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
00040  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00041  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00042  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
00043  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00044  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00045  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
00046  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00047  * SUCH DAMAGE.
00048  * ====================================================================
00049  *
00050  * This software consists of voluntary contributions made by many
00051  * individuals on behalf of the Apache Software Foundation and was
00052  * originally based on software copyright (c) 1999, International
00053  * Business Machines, Inc., http://www.ibm.com.  For more
00054  * information on the Apache Software Foundation, please see
00055  * <http://www.apache.org/>.
00056  */
00057 #if !defined(XALANTRANSFORMER_HEADER_GUARD)
00058 #define XALANTRANSFORMER_HEADER_GUARD
00059 
00060 
00061 
00062 // Base include file.  Must be first.
00063 #include <XalanTransformer/XalanTransformerDefinitions.hpp>
00064 
00065 
00066 
00067 #include <cassert>
00068 #include <vector>
00069 
00070 #if defined(XALAN_CLASSIC_IOSTREAMS)
00071 class ostream;
00072 #else
00073 #include <iosfwd>
00074 #endif
00075 
00076 
00077 
00078 #include <XPath/XalanQNameByValue.hpp>
00079 
00080 
00081 
00082 #include <XSLT/XSLTInputSource.hpp>
00083 #include <XSLT/XSLTResultTarget.hpp>
00084 
00085 
00086 
00087 XALAN_DECLARE_XERCES_CLASS(EntityResolver)
00088 XALAN_DECLARE_XERCES_CLASS(ErrorHandler)
00089 
00090 
00091 
00092 XALAN_CPP_NAMESPACE_BEGIN
00093 
00094 
00095 
00096 typedef XERCES_CPP_NAMESPACE_QUALIFIER EntityResolver   EntityResolverType;
00097 typedef XERCES_CPP_NAMESPACE_QUALIFIER ErrorHandler     ErrorHandlerType;
00098 
00099 
00100 
00101 class Function;
00102 class StylesheetExecutionContextDefault;
00103 class ProblemListener;
00104 class TraceListener;
00105 class XSLTInit;
00106 class XalanDocumentBuilder;
00107 class XalanCompiledStylesheet;
00108 class XalanParsedSource;
00109 class XalanTransformerOutputStream;
00110 
00111 
00112 
00119 class XALAN_TRANSFORMER_EXPORT XalanTransformer
00120 {
00121 public:
00122     
00123 #if defined(XALAN_NO_STD_NAMESPACE)
00124     typedef ostream         StreamType;
00125 #else
00126     typedef std::ostream    StreamType;
00127 #endif
00128 
00129     XalanTransformer();
00130 
00131     virtual
00132     ~XalanTransformer();
00133 
00142     static void
00143     initialize();
00144 
00157     static void
00158     terminate();
00159 
00178     static void
00179     ICUCleanUp();
00180 
00181 
00191     int
00192     transform(
00193             const XalanParsedSource&    theParsedXML, 
00194             const XSLTInputSource&      theStylesheetSource,
00195             const XSLTResultTarget&     theResultTarget)
00196     {
00197         return doTransform(theParsedXML, 0, &theStylesheetSource, theResultTarget);
00198     }
00199 
00209     int
00210     transform(
00211             const XalanParsedSource&        theParsedXML,
00212             const XalanCompiledStylesheet*  theCompiledStylesheet,
00213             const XSLTResultTarget&         theResultTarget)
00214     {
00215         assert(theCompiledStylesheet != 0);
00216 
00217         return doTransform(theParsedXML, theCompiledStylesheet, 0, theResultTarget);
00218     }
00219 
00229     int
00230     transform(
00231             const XalanParsedSource&    theParsedXML,                
00232             const XSLTResultTarget&     theResultTarget)
00233     {
00234 
00235         return transform(theParsedXML, s_emptyInputSource, theResultTarget);
00236     }
00237 
00249     int
00250     transform(
00251             const XSLTInputSource&      theInputSource,
00252             const XSLTInputSource&      theStylesheetSource,
00253             const XSLTResultTarget&     theResultTarget);
00254 
00265     int
00266     transform(
00267             const XSLTInputSource&      theInputSource,
00268             const XSLTResultTarget&     theResultTarget)
00269     {
00270         return transform(
00271                         theInputSource, 
00272                         s_emptyInputSource,
00273                         theResultTarget);
00274     }
00275 
00294     int
00295     transform(
00296             const XSLTInputSource&      theInputSource, 
00297             const XSLTInputSource&      theStylesheetSource,
00298             void*                       theOutputHandle, 
00299             XalanOutputHandlerType      theOutputHandler,
00300             XalanFlushHandlerType       theFlushHandler = 0);
00301     
00313     int
00314     transform(
00315             const XSLTInputSource&          theInputSource, 
00316             const XalanCompiledStylesheet*  theCompiledStylesheet,
00317             const XSLTResultTarget&         theResultTarget);
00318  
00337     int
00338     transform(
00339             const XalanParsedSource&        theParsedSource,
00340             const XalanCompiledStylesheet*  theCompiledStylesheet,
00341             void*                           theOutputHandle,
00342             XalanOutputHandlerType          theOutputHandler,
00343             XalanFlushHandlerType           theFlushHandler = 0);
00344 
00362     int
00363     transform(
00364             const XSLTInputSource&      theInputSource,
00365             void*                       theOutputHandle,
00366             XalanOutputHandlerType      theOutputHandler,
00367             XalanFlushHandlerType       theFlushHandler = 0);
00368 
00381     int
00382     compileStylesheet(
00383             const XSLTInputSource&              theStylesheetSource,
00384             const XalanCompiledStylesheet*&     theCompiledStylesheet);
00385 
00393     int
00394     destroyStylesheet(const XalanCompiledStylesheet*    theStylesheet);
00395 
00409     int
00410     parseSource(
00411             const XSLTInputSource&      theInputSource,
00412             const XalanParsedSource*&   theParsedSource,
00413             bool                        useXercesDOM = false);
00414 
00421     int
00422     destroyParsedSource(const XalanParsedSource*    theParsedSource);
00423 
00433     XalanDocumentBuilder*
00434     createDocumentBuilder();
00435 
00443     void
00444     destroyDocumentBuilder(XalanDocumentBuilder*    theDocumentBuilder);
00445 
00453     void
00454     installExternalFunction(
00455             const XalanDOMString&   theNamespace,
00456             const XalanDOMString&   functionName,
00457             const Function&         function);
00458 
00466     static void
00467     installExternalFunctionGlobal(
00468             const XalanDOMString&   theNamespace,
00469             const XalanDOMString&   functionName,
00470             const Function&         function);
00471 
00478     void
00479     uninstallExternalFunction(
00480             const XalanDOMString&   theNamespace,
00481             const XalanDOMString&   functionName);
00482 
00489     static void
00490     uninstallExternalFunctionGlobal(
00491             const XalanDOMString&   theNamespace,
00492             const XalanDOMString&   functionName);
00493 
00501     void
00502     setStylesheetParam(
00503             const XalanDOMString&   key,
00504             const XalanDOMString&   expression);
00505 
00513     void
00514     setStylesheetParam(
00515             const char*     key,
00516             const char*     expression);
00517 
00525     void
00526     addTraceListener(TraceListener*     theTraceListener)
00527     {
00528         m_traceListeners.push_back(theTraceListener);
00529     }
00530 
00537     bool
00538     removeTraceListener(TraceListener*  theTraceListener);
00539 
00543     void
00544     removeTraceListeners()
00545     {
00546         m_traceListeners.clear();
00547     }
00548 
00555     bool
00556     getUseValidation() const
00557     {
00558         return m_useValidation;
00559     }
00560 
00567     void
00568     setUseValidation(bool   fValue)
00569     {
00570         m_useValidation = fValue;
00571     }
00572 
00578     EntityResolverType*
00579     getEntityResolver() const
00580     {
00581         return m_entityResolver;
00582     }
00583 
00593     void
00594     setEntityResolver(EntityResolverType*   theResolver)
00595     {
00596         m_entityResolver = theResolver;
00597     }
00598 
00604     ErrorHandlerType*
00605     getErrorHandler() const
00606     {
00607         return m_errorHandler;
00608     }
00609 
00615     void
00616     setErrorHandler(ErrorHandlerType*   theErrorHandler)
00617     {
00618         m_errorHandler = theErrorHandler;
00619     }
00620 
00627     const XalanDOMChar*
00628     getExternalSchemaLocation() const
00629     {
00630         return m_externalSchemaLocation.size() == 0 ? 0 : m_externalSchemaLocation.c_str();
00631     }
00632 
00639     void
00640     setExternalSchemaLocation(const XalanDOMChar*   location)
00641     {
00642         assert(location != 0);
00643 
00644         m_externalSchemaLocation = location;
00645     }
00646 
00653     const XalanDOMChar*
00654     getExternalNoNamespaceSchemaLocation() const
00655     {
00656         return m_externalNoNamespaceSchemaLocation.size() == 0 ? 0 : m_externalNoNamespaceSchemaLocation.c_str();
00657     }
00658 
00665     void
00666     setExternalNoNamespaceSchemaLocation(const XalanDOMChar*    location)
00667     {
00668         assert(location != 0);
00669 
00670         m_externalNoNamespaceSchemaLocation = location;
00671     }
00672 
00678     ProblemListener*
00679     getProblemListener() const
00680     {
00681         return  m_problemListener;
00682     }
00683 
00689     void
00690     setProblemListener(ProblemListener*     theProblemListener)
00691     {
00692         m_problemListener = theProblemListener;
00693     }
00694 
00701     const char*
00702     getLastError() const
00703     {
00704         assert(m_errorMessage.size() > 0);
00705 
00706         return &m_errorMessage[0]; 
00707     }
00708 
00714     int
00715     getIndent() const;
00716 
00722     void
00723     setIndent(int   indentAmount);
00724 
00728     enum eEscapeURLs
00729     {
00730         eEscapeURLsDefault,     // Use the value in the stylesheet
00731         eEscapeURLsNo,          // Don't escape URLs
00732         eEscapeURLsYes          // Escape URLs
00733     };
00734 
00742     eEscapeURLs
00743     getEscapeURLs() const;
00744 
00752     void
00753     setEscapeURLs(eEscapeURLs   value);
00754 
00759     enum eOmitMETATag
00760     {
00761         eOmitMETATagDefault,    // Use the value in the stylesheet
00762         eOmitMETATagNo,         // Don't omit the META tag
00763         eOmitMETATagYes         // Omit the META tag
00764     };
00765 
00773     eOmitMETATag
00774     getOmitMETATag() const;
00775 
00783     void
00784     setOmitMETATag(eOmitMETATag     value);
00785 
00794     void
00795     setWarningStream(StreamType*    theStream)
00796     {
00797         m_warningStream = theStream;
00798     }
00799 
00805     StreamType*
00806     getWarningStream() const
00807     {
00808         return m_warningStream;
00809     }
00810 
00811 #if defined(XALAN_NO_STD_NAMESPACE)
00812     typedef vector<const XalanCompiledStylesheet*>      CompiledStylesheetPtrVectorType;
00813     typedef vector<const XalanParsedSource*>            ParsedSourcePtrVectorType;
00814     typedef pair<XalanDOMString, XalanDOMString>        ParamPairType;
00815     typedef vector<ParamPairType>                       ParamPairVectorType;
00816     typedef pair<XalanQNameByValue, Function*>          FunctionPairType;
00817     typedef vector<FunctionPairType>                    FunctionParamPairVectorType;
00818     typedef vector<TraceListener*>                      TraceListenerVectorType;
00819 #else
00820     typedef std::vector<const XalanCompiledStylesheet*> CompiledStylesheetPtrVectorType;
00821     typedef std::vector<const XalanParsedSource*>       ParsedSourcePtrVectorType;
00822     typedef std::pair<XalanDOMString, XalanDOMString>   ParamPairType;
00823     typedef std::vector<ParamPairType>                  ParamPairVectorType;
00824     typedef std::pair<XalanQNameByValue, Function*>     FunctionPairType;
00825     typedef std::vector<FunctionPairType>               FunctionParamPairVectorType;
00826     typedef std::vector<TraceListener*>                 TraceListenerVectorType;
00827 #endif
00828 
00829     class EnsureDestroyParsedSource
00830     {
00831     public:
00832 
00833         EnsureDestroyParsedSource(
00834                 XalanTransformer&           theTransformer,
00835                 const XalanParsedSource*    theParsedSource) :
00836             m_transformer(theTransformer),
00837             m_parsedSource(theParsedSource)
00838         {
00839         }
00840 
00841         ~EnsureDestroyParsedSource()
00842         {
00843             m_transformer.destroyParsedSource(m_parsedSource);
00844         }
00845 
00846     private:
00847 
00848         XalanTransformer&               m_transformer;
00849 
00850         const XalanParsedSource* const  m_parsedSource;
00851     };
00852 
00853     struct EnsureDestroyCompiledStylesheet
00854     {
00855         EnsureDestroyCompiledStylesheet(
00856                 XalanTransformer&               theTransformer,
00857                 const XalanCompiledStylesheet*  theCompiledStylesheet) :
00858             m_transformer(theTransformer),
00859             m_compiledStylesheet(theCompiledStylesheet)
00860         {
00861         }
00862 
00863         ~EnsureDestroyCompiledStylesheet()
00864         {
00865             m_transformer.destroyStylesheet(m_compiledStylesheet);
00866         }
00867 
00868     private:
00869 
00870         XalanTransformer&                       m_transformer;
00871 
00872         const XalanCompiledStylesheet* const    m_compiledStylesheet;
00873     };
00874 
00875     struct EnsureDestroyDocumentBuilder
00876     {
00877         EnsureDestroyDocumentBuilder(
00878                 XalanTransformer&       theTransformer,
00879                 XalanDocumentBuilder*   theDocumentBuilder) :
00880             m_transformer(theTransformer),
00881             m_documentBuilder(theDocumentBuilder)
00882         {
00883         }
00884 
00885         ~EnsureDestroyDocumentBuilder()
00886         {
00887             m_transformer.destroyDocumentBuilder(m_documentBuilder);
00888         }
00889 
00890     private:
00891 
00892         XalanTransformer&           m_transformer;
00893 
00894         XalanDocumentBuilder* const m_documentBuilder;
00895     };
00896 
00897 protected:
00898 
00899 private:
00900 
00901     void
00902     reset();
00903 
00904     class EnsureReset
00905     {
00906     public:
00907 
00908         EnsureReset(XalanTransformer&   theTransformer) :
00909             m_transformer(theTransformer)
00910         {
00911         }
00912 
00913         ~EnsureReset();
00914 
00915     private:
00916 
00917         XalanTransformer&   m_transformer;
00918     };
00919 
00920     friend class EnsureReset;
00921 
00922     int
00923     doTransform(
00924             const XalanParsedSource&        theParsedXML, 
00925             const XalanCompiledStylesheet*  theCompiledStylesheet,
00926             const XSLTInputSource*          theStylesheetSource,
00927             const XSLTResultTarget&         theResultTarget);
00928 
00929 
00930     // Data members...
00931     CompiledStylesheetPtrVectorType         m_compiledStylesheets;
00932 
00933     ParsedSourcePtrVectorType               m_parsedSources;
00934 
00935     ParamPairVectorType                     m_paramPairs;
00936 
00937     FunctionParamPairVectorType             m_functionPairs;
00938 
00939     TraceListenerVectorType                 m_traceListeners;
00940 
00941     CharVectorType                          m_errorMessage;
00942 
00943     bool                                    m_useValidation;
00944 
00945     EntityResolverType*                     m_entityResolver;
00946 
00947     ErrorHandlerType*                       m_errorHandler;
00948 
00949     XalanDOMString                          m_externalSchemaLocation;
00950 
00951     XalanDOMString                          m_externalNoNamespaceSchemaLocation;
00952 
00953     ProblemListener*                        m_problemListener;
00954 
00955     StreamType*                             m_warningStream;
00956 
00957     // This should always be the latest data member!!!
00958     StylesheetExecutionContextDefault*      m_stylesheetExecutionContext;
00959 
00960     static const XSLTInputSource            s_emptyInputSource;
00961 
00962     static const XSLTInit*                  s_xsltInit;
00963 };
00964 
00965 
00966 
00967 XALAN_CPP_NAMESPACE_END
00968 
00969 
00970 
00971 #endif  // XALANTRANSFORMER_HEADER_GUARD

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.5
Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.