## Xalan-C++ API Documentation

### The Xalan C++ XSLT Processor Version 1.9

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

# XalanTransformer.hpp

Go to the documentation of this file.

    00001 /*
    00002  * Copyright 1999-2004 The Apache Software Foundation.
    00003  *
    00004  * Licensed under the Apache License, Version 2.0 (the "License");
    00005  * you may not use this file except in compliance with the License.
    00006  * You may obtain a copy of the License at
    00007  *
    00008  *     http://www.apache.org/licenses/LICENSE-2.0
    00009  *
    00010  * Unless required by applicable law or agreed to in writing, software
    00011  * distributed under the License is distributed on an "AS IS" BASIS,
    00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00013  * See the License for the specific language governing permissions and
    00014  * limitations under the License.
    00015  */
    00016 #if !defined(XALANTRANSFORMER_HEADER_GUARD)
    00017 #define XALANTRANSFORMER_HEADER_GUARD
    00018
    00019
    00020
    00021 // Base include file.  Must be first.
    00022 #include <xalanc/XalanTransformer/XalanTransformerDefinitions.hpp>
    00023
    00024
    00025
    00026 #include <cassert>
    00027 #if defined(XALAN_CLASSIC_IOSTREAMS)
    00028 class ostream;
    00029 #else
    00030 #include <iosfwd>
    00031 #endif
    00032 #include <algorithm>
    00033
    00034
    00035
    00036 #include <xalanc/Include/XalanVector.hpp>
    00037
    00038
    00039
    00040 #include <xalanc/XPath/XalanQNameByValue.hpp>
    00041
    00042
    00043
    00044 #include <xalanc/XSLT/XSLTInputSource.hpp>
    00045 #include <xalanc/XSLT/XSLTResultTarget.hpp>
    00046
    00047
    00048
    00049 XALAN_DECLARE_XERCES_CLASS(EntityResolver)
    00050 XALAN_DECLARE_XERCES_CLASS(ErrorHandler)
    00051
    00052
    00053
    00054 XALAN_CPP_NAMESPACE_BEGIN
    00055
    00056
    00057
    00058 typedef XERCES_CPP_NAMESPACE_QUALIFIER EntityResolver   EntityResolverType;
    00059 typedef XERCES_CPP_NAMESPACE_QUALIFIER ErrorHandler     ErrorHandlerType;
    00060
    00061
    00062
    00063 class Function;
    00064 class StylesheetExecutionContextDefault;
    00065 class ProblemListener;
    00066 class TraceListener;
    00067 class XSLTInit;
    00068 class XalanDocumentBuilder;
    00069 class XalanCompiledStylesheet;
    00070 class XalanParsedSource;
    00071 class XalanTransformerOutputStream;
    00072
    00073
    00074
    00081 class XALAN_TRANSFORMER_EXPORT XalanTransformer
    00082 {
    00083
    00084 public:
    00085
    00086 #if defined(XALAN_NO_STD_NAMESPACE)
    00087     typedef ostream         StreamType;
    00088 #else
    00089     typedef std::ostream    StreamType;
    00090 #endif
    00091
    00092     XalanTransformer(MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr());
    00093
    00094     virtual
    00095     ~XalanTransformer();
    00096
    00097     MemoryManagerType&
    00098     getMemoryManager();
    00099
    00100
    00109     static void
    00110     initialize(MemoryManagerType&  theManager = XalanMemMgrs::getDefaultXercesMemMgr());
    00111
    00124     static void
    00125     terminate();
    00126
    00145     static void
    00146     ICUCleanUp();
    00147
    00148
    00149     static void
    00150     ICUStartUp(MemoryManagerType&  theManager = XalanMemMgrs::getDefaultXercesMemMgr());
    00151
    00161     int
    00162     transform(
    00163             const XalanParsedSource&    theParsedXML,
    00164             const XSLTInputSource&      theStylesheetSource,
    00165             const XSLTResultTarget&     theResultTarget)
    00166     {
    00167         return doTransform(theParsedXML, 0, &theStylesheetSource, theResultTarget);
    00168     }
    00169
    00179     int
    00180     transform(
    00181             const XalanParsedSource&        theParsedXML,
    00182             const XalanCompiledStylesheet*  theCompiledStylesheet,
    00183             const XSLTResultTarget&         theResultTarget)
    00184     {
    00185         assert(theCompiledStylesheet != 0);
    00186
    00187         return doTransform(theParsedXML, theCompiledStylesheet, 0, theResultTarget);
    00188     }
    00189
    00199     int
    00200     transform(
    00201             const XalanParsedSource&    theParsedXML,
    00202             const XSLTResultTarget&     theResultTarget)
    00203     {
    00204         assert(s_emptyInputSource != 0);
    00205
    00206         return transform(theParsedXML, *s_emptyInputSource, theResultTarget);
    00207     }
    00208
    00220     int
    00221     transform(
    00222             const XSLTInputSource&      theInputSource,
    00223             const XSLTInputSource&      theStylesheetSource,
    00224             const XSLTResultTarget&     theResultTarget);
    00225
    00236     int
    00237     transform(
    00238             const XSLTInputSource&      theInputSource,
    00239             const XSLTResultTarget&     theResultTarget)
    00240     {
    00241         assert(s_emptyInputSource != 0);
    00242
    00243         return transform(
    00244                         theInputSource,
    00245                         *s_emptyInputSource,
    00246                         theResultTarget);
    00247     }
    00248
    00267     int
    00268     transform(
    00269             const XSLTInputSource&      theInputSource,
    00270             const XSLTInputSource&      theStylesheetSource,
    00271             void*                       theOutputHandle,
    00272             XalanOutputHandlerType      theOutputHandler,
    00273             XalanFlushHandlerType       theFlushHandler = 0);
    00274
    00286     int
    00287     transform(
    00288             const XSLTInputSource&          theInputSource,
    00289             const XalanCompiledStylesheet*  theCompiledStylesheet,
    00290             const XSLTResultTarget&         theResultTarget);
    00291
    00310     int
    00311     transform(
    00312             const XalanParsedSource&        theParsedSource,
    00313             const XalanCompiledStylesheet*  theCompiledStylesheet,
    00314             void*                           theOutputHandle,
    00315             XalanOutputHandlerType          theOutputHandler,
    00316             XalanFlushHandlerType           theFlushHandler = 0);
    00317
    00335     int
    00336     transform(
    00337             const XSLTInputSource&      theInputSource,
    00338             void*                       theOutputHandle,
    00339             XalanOutputHandlerType      theOutputHandler,
    00340             XalanFlushHandlerType       theFlushHandler = 0);
    00341
    00354     int
    00355     compileStylesheet(
    00356             const XSLTInputSource&              theStylesheetSource,
    00357             const XalanCompiledStylesheet*&     theCompiledStylesheet);
    00358
    00366     int
    00367     destroyStylesheet(const XalanCompiledStylesheet*    theStylesheet);
    00368
    00382     int
    00383     parseSource(
    00384             const XSLTInputSource&      theInputSource,
    00385             const XalanParsedSource*&   theParsedSource,
    00386             bool                        useXercesDOM = false);
    00387
    00394     int
    00395     destroyParsedSource(const XalanParsedSource*    theParsedSource);
    00396
    00407     XalanDocumentBuilder*
    00408     createDocumentBuilder(const XalanDOMString&     theURI = XalanDOMString(XalanMemMgrs::getDummyMemMgr()));
    00409
    00417     void
    00418     destroyDocumentBuilder(XalanDocumentBuilder*    theDocumentBuilder);
    00419
    00427     void
    00428     installExternalFunction(
    00429             const XalanDOMString&   theNamespace,
    00430             const XalanDOMString&   functionName,
    00431             const Function&         function);
    00432
    00440     static void
    00441     installExternalFunctionGlobal(
    00442             const XalanDOMString&   theNamespace,
    00443             const XalanDOMString&   functionName,
    00444             const Function&         function);
    00445
    00452     void
    00453     uninstallExternalFunction(
    00454             const XalanDOMString&   theNamespace,
    00455             const XalanDOMString&   functionName);
    00456
    00463     static void
    00464     uninstallExternalFunctionGlobal(
    00465             const XalanDOMString&   theNamespace,
    00466             const XalanDOMString&   functionName);
    00467
    00475     void
    00476     setStylesheetParam(
    00477             const XalanDOMString&   key,
    00478             const XalanDOMString&   expression);
    00479
    00487     void
    00488     setStylesheetParam(
    00489             const char*     key,
    00490             const char*     expression);
    00491
    00499     void
    00500     addTraceListener(TraceListener*     theTraceListener)
    00501     {
    00502         m_traceListeners.push_back(theTraceListener);
    00503     }
    00504
    00511     bool
    00512     removeTraceListener(TraceListener*  theTraceListener);
    00513
    00517     void
    00518     removeTraceListeners()
    00519     {
    00520         m_traceListeners.clear();
    00521     }
    00522
    00529     bool
    00530     getUseValidation() const
    00531     {
    00532         return m_useValidation;
    00533     }
    00534
    00541     void
    00542     setUseValidation(bool   fValue)
    00543     {
    00544         m_useValidation = fValue;
    00545     }
    00546
    00552     EntityResolverType*
    00553     getEntityResolver() const
    00554     {
    00555         return m_entityResolver;
    00556     }
    00557
    00567     void
    00568     setEntityResolver(EntityResolverType*   theResolver)
    00569     {
    00570         m_entityResolver = theResolver;
    00571     }
    00572
    00578     ErrorHandlerType*
    00579     getErrorHandler() const
    00580     {
    00581         return m_errorHandler;
    00582     }
    00583
    00589     void
    00590     setErrorHandler(ErrorHandlerType*   theErrorHandler)
    00591     {
    00592         m_errorHandler = theErrorHandler;
    00593     }
    00594
    00601     const XalanDOMChar*
    00602     getExternalSchemaLocation() const
    00603     {
    00604         return m_externalSchemaLocation.empty() == true ? 0 : m_externalSchemaLocation.c_str();
    00605     }
    00606
    00613     void
    00614     setExternalSchemaLocation(const XalanDOMChar*   location)
    00615     {
    00616         assert(location != 0);
    00617
    00618         m_externalSchemaLocation = location;
    00619     }
    00620
    00627     const XalanDOMChar*
    00628     getExternalNoNamespaceSchemaLocation() const
    00629     {
    00630         return m_externalNoNamespaceSchemaLocation.empty() == true ? 0 : m_externalNoNamespaceSchemaLocation.c_str();
    00631     }
    00632
    00639     void
    00640     setExternalNoNamespaceSchemaLocation(const XalanDOMChar*    location)
    00641     {
    00642         assert(location != 0);
    00643
    00644         m_externalNoNamespaceSchemaLocation = location;
    00645     }
    00646
    00653     bool
    00654     getPoolAllTextNodes() const
    00655     {
    00656         return m_poolAllTextNodes;
    00657     }
    00658
    00667     void
    00668     setPoolAllTextNodes(bool    fPool)
    00669     {
    00670         m_poolAllTextNodes = fPool;
    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.empty() == false);
    00705
    00706         return &m_errorMessage[0];
    00707     }
    00708
    00715     const XalanDOMString&
    00716     getOutputEncoding() const
    00717     {
    00718         return m_outputEncoding;
    00719     }
    00720
    00729     void
    00730     setOutputEncoding(const XalanDOMString&     theEncoding)
    00731     {
    00732         m_outputEncoding = theEncoding;
    00733     }
    00734
    00740     int
    00741     getIndent() const;
    00742
    00748     void
    00749     setIndent(int   indentAmount);
    00750
    00754     enum eEscapeURLs
    00755     {
    00756         eEscapeURLsDefault,     // Use the value in the stylesheet
    00757         eEscapeURLsNo,          // Don't escape URLs
    00758         eEscapeURLsYes          // Escape URLs
    00759     };
    00760
    00768     eEscapeURLs
    00769     getEscapeURLs() const;
    00770
    00778     void
    00779     setEscapeURLs(eEscapeURLs   value);
    00780
    00785     enum eOmitMETATag
    00786     {
    00787         eOmitMETATagDefault,    // Use the value in the stylesheet
    00788         eOmitMETATagNo,         // Don't omit the META tag
    00789         eOmitMETATagYes         // Omit the META tag
    00790     };
    00791
    00799     eOmitMETATag
    00800     getOmitMETATag() const;
    00801
    00809     void
    00810     setOmitMETATag(eOmitMETATag     value);
    00811
    00820     void
    00821     setWarningStream(StreamType*    theStream)
    00822     {
    00823         m_warningStream = theStream;
    00824     }
    00825
    00831     StreamType*
    00832     getWarningStream() const
    00833     {
    00834         return m_warningStream;
    00835     }
    00836
    00837     typedef XalanVector<const XalanCompiledStylesheet*> CompiledStylesheetPtrVectorType;
    00838     typedef XalanVector<const XalanParsedSource*>       ParsedSourcePtrVectorType;
    00839     typedef XALAN_STD_QUALIFIER pair<XalanDOMString*, XalanDOMString*>      ParamPairType;
    00840     typedef XalanVector<ParamPairType>                  ParamPairVectorType;
    00841     typedef XALAN_STD_QUALIFIER pair<XalanQNameByValue*, Function*>         FunctionPairType;
    00842     typedef XalanVector<FunctionPairType>               FunctionParamPairVectorType;
    00843     typedef XalanVector<TraceListener*>                 TraceListenerVectorType;
    00844
    00845     class EnsureFunctionsInstallation
    00846     {
    00847     public:
    00848
    00849         EnsureFunctionsInstallation(MemoryManagerType& theManager) :
    00850           m_memoryManagement(theManager),
    00851           m_release(false)
    00852         {
    00853         }
    00854
    00855         ~EnsureFunctionsInstallation();
    00856
    00857         void
    00858         install();
    00859
    00860         void
    00861         release()
    00862         {
    00863             m_release = true;
    00864         }
    00865
    00866     private:
    00867         MemoryManagerType& m_memoryManagement;
    00868
    00869         bool m_release;
    00870     };
    00871
    00872     class EnsureDestroyParsedSource
    00873     {
    00874     public:
    00875
    00876         EnsureDestroyParsedSource(
    00877                 XalanTransformer&           theTransformer,
    00878                 const XalanParsedSource*    theParsedSource) :
    00879             m_transformer(theTransformer),
    00880             m_parsedSource(theParsedSource)
    00881         {
    00882         }
    00883
    00884         ~EnsureDestroyParsedSource()
    00885         {
    00886             m_transformer.destroyParsedSource(m_parsedSource);
    00887         }
    00888
    00889     private:
    00890
    00891         XalanTransformer&               m_transformer;
    00892
    00893         const XalanParsedSource* const  m_parsedSource;
    00894     };
    00895
    00896     struct EnsureDestroyCompiledStylesheet
    00897     {
    00898         EnsureDestroyCompiledStylesheet(
    00899                 XalanTransformer&               theTransformer,
    00900                 const XalanCompiledStylesheet*  theCompiledStylesheet) :
    00901             m_transformer(theTransformer),
    00902             m_compiledStylesheet(theCompiledStylesheet)
    00903         {
    00904         }
    00905
    00906         ~EnsureDestroyCompiledStylesheet()
    00907         {
    00908             m_transformer.destroyStylesheet(m_compiledStylesheet);
    00909         }
    00910
    00911     private:
    00912
    00913         XalanTransformer&                       m_transformer;
    00914
    00915         const XalanCompiledStylesheet* const    m_compiledStylesheet;
    00916     };
    00917
    00918     struct EnsureDestroyDocumentBuilder
    00919     {
    00920         EnsureDestroyDocumentBuilder(
    00921                 XalanTransformer&       theTransformer,
    00922                 XalanDocumentBuilder*   theDocumentBuilder) :
    00923             m_transformer(theTransformer),
    00924             m_documentBuilder(theDocumentBuilder)
    00925         {
    00926         }
    00927
    00928         ~EnsureDestroyDocumentBuilder()
    00929         {
    00930             m_transformer.destroyDocumentBuilder(m_documentBuilder);
    00931         }
    00932
    00933     private:
    00934
    00935         XalanTransformer&           m_transformer;
    00936
    00937         XalanDocumentBuilder* const m_documentBuilder;
    00938     };
    00939     template <class T>
    00940 #if defined(XALAN_NO_STD_NAMESPACE)
    00941     struct DeleteParamPairFunctor : public unary_function<T&, void>
    00942 #else
    00943     struct DeleteParamPairFunctor : public std::unary_function<T&, void>
    00944 #endif
    00945     {
    00946 #if defined(XALAN_NO_STD_NAMESPACE)
    00947         typedef unary_function<T&, void>    BaseClassType;
    00948 #else
    00949         typedef std::unary_function<T&, void>   BaseClassType;
    00950 #endif
    00951
    00952         typedef typename BaseClassType::result_type     result_type;
    00953         typedef typename BaseClassType::argument_type   argument_type;
    00954
    00955         DeleteParamPairFunctor(MemoryManagerType&      theManager) :
    00956         m_memoryManager(theManager)
    00957         {
    00958         }
    00959
    00960         template<class PtrT>
    00961     void
    00962         deletePtr(PtrT* ptr)const
    00963         {
    00964             ptr->~PtrT();
    00965         }
    00966
    00972         result_type
    00973             operator()(argument_type    thePair) const
    00974         {
    00975             T&  tmpPair = const_cast<T&>(thePair);
    00976
    00977             if (tmpPair.first != 0)
    00978             {
    00979                 deletePtr(tmpPair.first);
    00980
    00981                 m_memoryManager.deallocate((void*)tmpPair.first);
    00982             }
    00983
    00984             if (tmpPair.second != 0)
    00985             {
    00986                 deletePtr(tmpPair.second);
    00987
    00988                 m_memoryManager.deallocate((void*)tmpPair.second);
    00989             }
    00990
    00991
    00992         }
    00993
    00994     private:
    00995
    00996         MemoryManagerType& m_memoryManager;
    00997
    00998     };
    00999 protected:
    01000
    01001 private:
    01002
    01003     void
    01004     reset();
    01005
    01006     class EnsureReset
    01007     {
    01008     public:
    01009
    01010         EnsureReset(XalanTransformer&   theTransformer) :
    01011             m_transformer(theTransformer)
    01012         {
    01013         }
    01014
    01015         ~EnsureReset();
    01016
    01017     private:
    01018
    01019         XalanTransformer&   m_transformer;
    01020     };
    01021
    01022     friend class EnsureReset;
    01023
    01024     int
    01025     doTransform(
    01026             const XalanParsedSource&        theParsedXML,
    01027             const XalanCompiledStylesheet*  theCompiledStylesheet,
    01028             const XSLTInputSource*          theStylesheetSource,
    01029             const XSLTResultTarget&         theResultTarget);
    01030
    01031
    01032     // Data members...
    01033     MemoryManagerType&                      m_memoryManager;
    01034
    01035     CompiledStylesheetPtrVectorType         m_compiledStylesheets;
    01036
    01037     ParsedSourcePtrVectorType               m_parsedSources;
    01038
    01039     ParamPairVectorType                     m_paramPairs;
    01040
    01041     FunctionParamPairVectorType             m_functionPairs;
    01042
    01043     TraceListenerVectorType                 m_traceListeners;
    01044
    01045     CharVectorType                          m_errorMessage;
    01046
    01047     bool                                    m_useValidation;
    01048
    01049     EntityResolverType*                     m_entityResolver;
    01050
    01051     ErrorHandlerType*                       m_errorHandler;
    01052
    01053     XalanDOMString                          m_externalSchemaLocation;
    01054
    01055     XalanDOMString                          m_externalNoNamespaceSchemaLocation;
    01056
    01057     ProblemListener*                        m_problemListener;
    01058
    01059     StreamType*                             m_warningStream;
    01060
    01061     XalanDOMString                          m_outputEncoding;
    01062
    01063     bool                                    m_poolAllTextNodes;
    01064
    01065     // This should always be the latest data member!!!
    01066     StylesheetExecutionContextDefault*      m_stylesheetExecutionContext;
    01067
    01068     static const XSLTInputSource*           s_emptyInputSource;
    01069
    01070     static const XSLTInit*                  s_xsltInit;
    01071 };
    01072
    01073
    01074
    01075 XALAN_CPP_NAMESPACE_END
    01076
    01077
    01078
    01079 #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.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.