## Xalan-C++ API Documentation

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

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

# StylesheetExecutionContext.hpp

Go to the documentation of this file.

    00001 /*
    00002  * The Apache Software License, Version 1.1
    00003  *
    00004  *
    00005  * Copyright (c) 1999-2004 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  * @author <a href="mailto:david_n_bertoni@lotus.com">David N. Bertoni</a>
    00058  */
    00059 #if !defined(STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680)
    00060 #define STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680
    00061
    00062
    00063
    00064 // Base include file.  Must be first.
    00065 #include <xalanc/XSLT/XSLTDefinitions.hpp>
    00066
    00067
    00068
    00069 #include <cstddef>
    00070 #include <cstdio>
    00071 #include <memory>
    00072
    00073
    00074
    00075 // Base class header file...
    00076 #include <xalanc/XPath/XPathExecutionContext.hpp>
    00077
    00078
    00079
    00080 #include <xalanc/XalanDOM/XalanDOMString.hpp>
    00081
    00082
    00083
    00084 // Base class header file...
    00085 #include <xalanc/PlatformSupport/ExecutionContext.hpp>
    00086
    00087
    00088
    00089 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
    00090 #include <xalanc/PlatformSupport/XalanNumberFormat.hpp>
    00091 #endif
    00092
    00093
    00094
    00095 #include <xalanc/Include/XalanAutoPtr.hpp>
    00096
    00097
    00098
    00099 #include <xalanc/PlatformSupport/AttributeListImpl.hpp>
    00100 #include <xalanc/PlatformSupport/XalanCollationServices.hpp>
    00101
    00102
    00103
    00104 #include <xalanc/XSLT/TopLevelArg.hpp>
    00105
    00106
    00107
    00108 XALAN_CPP_NAMESPACE_BEGIN
    00109
    00110
    00111
    00112 class CountersTable;
    00113 class ElemTemplate;
    00114 class ElemTemplateElement;
    00115 class ElemVariable;
    00116 class FormatterListener;
    00117 class FormatterToText;
    00118 class GenerateEvent;
    00119 class KeyDeclaration;
    00120 class PrefixResolver;
    00121 class NodeRefListBase;
    00122 class NodeSorter;
    00123 class PrintWriter;
    00124 class XalanQName;
    00125 class SelectionEvent;
    00126 class Stylesheet;
    00127 class StylesheetRoot;
    00128 class XalanOutputStream;
    00129 class TracerEvent;
    00130 class Writer;
    00131 class XalanDocument;
    00132 class XalanDocumentFragment;
    00133 class XalanElement;
    00134 class XalanNode;
    00135 class XalanNumberFormat;
    00136 class XPath;
    00137 class XObject;
    00138 class XObjectPtr;
    00139 class XResultTreeFrag;
    00140
    00141
    00142
    00143 //
    00144 // An abstract class which provides support for executing stylesheets.
    00145 //
    00146 class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext
    00147 {
    00148 public:
    00149
    00150 #if defined(XALAN_NO_STD_NAMESPACE)
    00151     typedef ostream         StreamType;
    00152 #else
    00153     typedef std::ostream    StreamType;
    00154 #endif
    00155
    00156     typedef size_t  size_type;
    00157
    00158     explicit
    00159     StylesheetExecutionContext(XObjectFactory*  theXObjectFactory = 0);
    00160
    00161     virtual
    00162     ~StylesheetExecutionContext();
    00163
    00164     // These interfaces are new...
    00165
    00173     virtual void
    00174     error(
    00175             const XalanDOMString&       msg,
    00176             const ElemTemplateElement&  styleNode,
    00177             const XalanNode*            sourceNode = 0) const = 0;
    00178
    00186     virtual void
    00187     error(
    00188             const char*                 msg,
    00189             const ElemTemplateElement&  styleNode,
    00190             const XalanNode*            sourceNode = 0) const = 0;
    00191
    00199     virtual void
    00200     warn(
    00201             const XalanDOMString&       msg,
    00202             const ElemTemplateElement&  styleNode,
    00203             const XalanNode*            sourceNode = 0) const = 0;
    00204
    00212     virtual void
    00213     warn(
    00214             const char*                 msg,
    00215             const ElemTemplateElement&  styleNode,
    00216             const XalanNode*            sourceNode = 0) const = 0;
    00217
    00225     virtual void
    00226     message(
    00227             const XalanDOMString&       msg,
    00228             const ElemTemplateElement&  styleNode,
    00229             const XalanNode*            sourceNode = 0) const = 0;
    00230
    00231
    00239     virtual void
    00240     message(
    00241             const char*                 msg,
    00242             const ElemTemplateElement&  styleNode,
    00243             const XalanNode*            sourceNode = 0) const = 0;
    00244
    00250     virtual bool
    00251     getQuietConflictWarnings() const = 0;
    00252
    00259     virtual bool
    00260     getCopyTextNodesOnly() const = 0;
    00261
    00268     virtual void
    00269     setCopyTextNodesOnly(bool   fValue) = 0;
    00270
    00271     /*
    00272      * A class to manage setting and restoring the flag
    00273      * for restricting copying only text nodes to the
    00274      * result tree
    00275      */
    00276     class SetAndRestoreCopyTextNodesOnly
    00277     {
    00278     public:
    00279
    00280         SetAndRestoreCopyTextNodesOnly(
    00281             StylesheetExecutionContext&     executionContext,
    00282             bool                            fValue) :
    00283             m_executionContext(executionContext),
    00284             m_fValue(executionContext.getCopyTextNodesOnly())
    00285         {
    00286             executionContext.setCopyTextNodesOnly(fValue);
    00287         }
    00288
    00289         ~SetAndRestoreCopyTextNodesOnly()
    00290         {
    00291             m_executionContext.setCopyTextNodesOnly(m_fValue);
    00292         }
    00293
    00294     private:
    00295
    00296         // Not implemented...
    00297         SetAndRestoreCopyTextNodesOnly(const SetAndRestoreCopyTextNodesOnly&);
    00298
    00299         SetAndRestoreCopyTextNodesOnly&
    00300         operator=(const SetAndRestoreCopyTextNodesOnly&);
    00301
    00302         // Data members...
    00303         StylesheetExecutionContext&     m_executionContext;
    00304
    00305         const bool                      m_fValue;
    00306     };
    00307
    00315     virtual XalanNode*
    00316     getRootDocument() const = 0;
    00317
    00325     virtual void
    00326     setRootDocument(XalanNode*  theDocument) = 0;
    00327
    00333     virtual XalanDocument*
    00334     createDocument() const = 0;
    00335
    00341     virtual void
    00342     setStylesheetRoot(const StylesheetRoot*     theStylesheet) = 0;
    00343
    00349     virtual const XalanQName*
    00350     getCurrentMode() const = 0;
    00351
    00357     virtual void
    00358     setCurrentMode(const XalanQName* theMode) = 0;
    00359
    00365     virtual const ElemTemplate*
    00366     getCurrentTemplate() const = 0;
    00367
    00373     virtual void
    00374     pushCurrentTemplate(const ElemTemplate*     theTemplate) = 0;
    00375
    00376     virtual void
    00377     popCurrentTemplate() = 0;
    00378
    00379     /*
    00380      * A class to manage pushing and popping the current
    00381      * template instance.
    00382      */
    00383     class PushAndPopCurrentTemplate
    00384     {
    00385     public:
    00386
    00387         PushAndPopCurrentTemplate(
    00388             StylesheetExecutionContext&     executionContext,
    00389             const ElemTemplate*             theTemplate) :
    00390             m_executionContext(executionContext)
    00391         {
    00392             executionContext.pushCurrentTemplate(theTemplate);
    00393         }
    00394
    00395         ~PushAndPopCurrentTemplate()
    00396         {
    00397             m_executionContext.popCurrentTemplate();
    00398         }
    00399
    00400     private:
    00401
    00402         // Data members...
    00403         StylesheetExecutionContext&     m_executionContext;
    00404     };
    00405
    00411     virtual bool
    00412     doDiagnosticsOutput() const = 0;
    00413
    00419     virtual void
    00420     diag(const XalanDOMString&  theString) = 0;
    00421
    00428     virtual void
    00429     pushTime(const void*    theKey) = 0;
    00430
    00437     virtual void
    00438     displayDuration(
    00439             const XalanDOMString&   theMessage,
    00440             const void*             theKey) = 0;
    00441
    00445     virtual bool
    00446     isElementPending() const = 0;
    00447
    00455     virtual void
    00456     replacePendingAttribute(
    00457             const XalanDOMChar*     theName,
    00458             const XalanDOMChar*     theNewType,
    00459             const XalanDOMChar*     theNewValue) = 0;
    00460
    00466     virtual FormatterListener*
    00467     getFormatterListener() const = 0;
    00468
    00474     virtual void
    00475     setFormatterListener(FormatterListener*     flistener) = 0;
    00476
    00477     virtual void
    00478     pushOutputContext(FormatterListener*    flistener = 0) = 0;
    00479
    00480     virtual void
    00481     popOutputContext() = 0;
    00482
    00483     class OutputContextPushPop
    00484     {
    00485     public:
    00486
    00493         OutputContextPushPop(
    00494             StylesheetExecutionContext&     theExecutionContext,
    00495             FormatterListener*              theNewListener = 0) :
    00496             m_executionContext(theExecutionContext)
    00497         {
    00498             m_executionContext.pushOutputContext(theNewListener);
    00499         }
    00500
    00501         ~OutputContextPushPop()
    00502         {
    00503             m_executionContext.popOutputContext();
    00504         }
    00505
    00506     private:
    00507
    00508         StylesheetExecutionContext&     m_executionContext;
    00509     };
    00510
    00517     virtual void
    00518     addResultAttribute(
    00519             const XalanDOMString&   aname,
    00520             const XalanDOMString&   value) = 0;
    00521
    00528     virtual void
    00529     addResultAttribute(
    00530             const XalanDOMString&   aname,
    00531             const XalanDOMChar*     value) = 0;
    00532
    00538     virtual void
    00539     copyNamespaceAttributes(const XalanNode&    src) = 0;
    00540
    00548     virtual const XalanDOMString*
    00549     getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const = 0;
    00550
    00558     virtual const XalanDOMString*
    00559     getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const = 0;
    00560
    00569     virtual bool
    00570     isPendingResultPrefix(const XalanDOMString& thePrefix) = 0;
    00571
    00577     virtual XalanDOMString
    00578     getUniqueNamespaceValue() const = 0;
    00579
    00585     virtual void
    00586     getUniqueNamespaceValue(XalanDOMString&     theValue) const = 0;
    00587
    00593     virtual int
    00594     getIndent() const = 0;
    00595
    00601     virtual void
    00602     setIndent(int   indentAmount) = 0;
    00603
    00612     virtual const XPath*
    00613     createMatchPattern(
    00614             const XalanDOMString&   str,
    00615             const PrefixResolver&   resolver) = 0;
    00616
    00622     virtual void
    00623     returnXPath(const XPath*    xpath) = 0;
    00624
    00625     // A helper class to automatically return an XPath instance.
    00626     class XPathGuard
    00627     {
    00628     public:
    00629
    00630         XPathGuard(
    00631                 StylesheetExecutionContext&     context,
    00632                 const XPath*                    xpath = 0) :
    00633             m_context(context),
    00634             m_xpath(xpath)
    00635         {
    00636         }
    00637
    00638         ~XPathGuard()
    00639         {
    00640             if (m_xpath != 0)
    00641             {
    00642                 m_context.returnXPath(m_xpath);
    00643             }
    00644         }
    00645
    00646         const XPath*
    00647         get() const
    00648         {
    00649             return m_xpath;
    00650         }
    00651
    00652         const XPath*
    00653         release()
    00654         {
    00655             const XPath* const  temp = m_xpath;
    00656
    00657             m_xpath = 0;
    00658
    00659             return temp;
    00660         }
    00661
    00662         void
    00663         reset(const XPath*  xpath)
    00664         {
    00665             if (m_xpath != 0)
    00666             {
    00667                 m_context.returnXPath(m_xpath);
    00668             }
    00669
    00670             m_xpath = xpath;
    00671         }
    00672
    00673     private:
    00674
    00675         StylesheetExecutionContext&     m_context;
    00676
    00677         const XPath*                    m_xpath;
    00678     };
    00679
    00680 #if defined(XALAN_NO_STD_NAMESPACE)
    00681     typedef vector<TopLevelArg>         ParamVectorType;
    00682 #else
    00683     typedef std::vector<TopLevelArg>    ParamVectorType;
    00684 #endif
    00685
    00692     virtual void
    00693     pushTopLevelVariables(const ParamVectorType&    topLevelParams) = 0;
    00694
    00704     virtual const XObjectPtr
    00705     createVariable(
    00706             const XPath&                xpath,
    00707             XalanNode*                  contextNode,
    00708             const PrefixResolver&       resolver) = 0;
    00709
    00718     virtual const XObjectPtr
    00719     createVariable(
    00720             const ElemTemplateElement&  templateChild,
    00721             XalanNode*                  sourceNode) = 0;
    00722
    00735     virtual void
    00736     pushVariable(
    00737             const XalanQName&           name,
    00738             const ElemTemplateElement*  element,
    00739             const XalanDOMString&       str,
    00740             XalanNode*                  contextNode,
    00741             const PrefixResolver&       resolver) = 0;
    00742
    00754     virtual void
    00755     pushVariable(
    00756             const XalanQName&           name,
    00757             const ElemTemplateElement*  element,
    00758             const XPath&                xpath,
    00759             XalanNode*                  contextNode,
    00760             const PrefixResolver&       resolver) = 0;
    00761
    00771     virtual void
    00772     pushVariable(
    00773             const XalanQName&           name,
    00774             const ElemTemplateElement*  element,
    00775             const ElemTemplateElement&  templateChild,
    00776             XalanNode*                  sourceNode) = 0;
    00777
    00786     virtual void
    00787     pushVariable(
    00788             const XalanQName&           name,
    00789             const XObjectPtr            val,
    00790             const ElemTemplateElement*  element) = 0;
    00791
    00800     virtual void
    00801     pushVariable(
    00802             const XalanQName&           name,
    00803             const ElemVariable*         var,
    00804             const ElemTemplateElement*  element) = 0;
    00805
    00810     virtual void
    00811     pushContextMarker() = 0;
    00812
    00816     virtual void
    00817     popContextMarker() = 0;
    00818
    00819     /*
    00820      * A class to manage pushing and popping an element's stack
    00821      * frame context.
    00822      */
    00823     class PushAndPopContextMarker
    00824     {
    00825     public:
    00826
    00827         PushAndPopContextMarker(StylesheetExecutionContext&     executionContext) :
    00828             m_executionContext(executionContext)
    00829         {
    00830             executionContext.pushContextMarker();
    00831         }
    00832
    00833         PushAndPopContextMarker(
    00834                 StylesheetExecutionContext&     executionContext,
    00835                 int&                            currentStackFrameIndex) :
    00836             m_executionContext(executionContext)
    00837         {
    00838             currentStackFrameIndex = executionContext.getCurrentStackFrameIndex();
    00839
    00840             executionContext.pushContextMarker();
    00841         }
    00842
    00843         ~PushAndPopContextMarker()
    00844         {
    00845             m_executionContext.popContextMarker();
    00846         }
    00847
    00848         StylesheetExecutionContext&
    00849         getExecutionContext() const
    00850         {
    00851             return m_executionContext;
    00852         }
    00853
    00854     private:
    00855
    00856         StylesheetExecutionContext&     m_executionContext;
    00857     };
    00858
    00862     virtual void
    00863     resolveTopLevelParams() = 0;
    00864
    00868     virtual void
    00869     clearTopLevelParams() = 0;
    00870
    00871     class ResolveAndClearTopLevelParams
    00872     {
    00873     public:
    00874
    00875         ResolveAndClearTopLevelParams(StylesheetExecutionContext&   executionContext) :
    00876             m_executionContext(executionContext)
    00877         {
    00878             m_executionContext.resolveTopLevelParams();
    00879         }
    00880
    00881         ~ResolveAndClearTopLevelParams()
    00882         {
    00883             m_executionContext.clearTopLevelParams();
    00884         }
    00885
    00886     private:
    00887
    00888         StylesheetExecutionContext&     m_executionContext;
    00889     };
    00890
    00897     virtual void
    00898     pushParams(const ElemTemplateElement&   xslCallTemplateElement) = 0;
    00899
    00907     virtual const XObjectPtr
    00908     getParamVariable(const XalanQName&  theName) = 0;
    00909
    00915     virtual void
    00916     pushElementFrame(const ElemTemplateElement*     elem) = 0;
    00917
    00923     virtual void
    00924     popElementFrame() = 0;
    00925
    00926     /*
    00927      * A class to manage pushing and popping an element's stack
    00928      * frame context.
    00929      */
    00930     class PushAndPopElementFrame
    00931     {
    00932     public:
    00933
    00934         PushAndPopElementFrame(
    00935             StylesheetExecutionContext&     executionContext,
    00936             const ElemTemplateElement*      element) :
    00937             m_executionContext(executionContext)
    00938         {
    00939             executionContext.pushElementFrame(element);
    00940         }
    00941
    00942         ~PushAndPopElementFrame()
    00943         {
    00944             m_executionContext.popElementFrame();
    00945         }
    00946
    00947     private:
    00948
    00949         StylesheetExecutionContext&     m_executionContext;
    00950     };
    00951
    00957     virtual int
    00958     getGlobalStackFrameIndex() const = 0;
    00959
    00966     virtual int
    00967     getCurrentStackFrameIndex() const = 0;
    00968
    00975     virtual void
    00976     setCurrentStackFrameIndex(int   currentStackFrameIndex = -1) = 0;
    00977
    00978     /*
    00979      * A class to manage the state of the variable stacks frame index.
    00980      */
    00981     class SetAndRestoreCurrentStackFrameIndex
    00982     {
    00983     public:
    00984
    00985         SetAndRestoreCurrentStackFrameIndex(
    00986             StylesheetExecutionContext&     executionContext,
    00987             int                             newIndex) :
    00988             m_executionContext(executionContext),
    00989             m_savedIndex(executionContext.getCurrentStackFrameIndex())
    00990         {
    00991             executionContext.setCurrentStackFrameIndex(newIndex);
    00992         }
    00993
    00994         ~SetAndRestoreCurrentStackFrameIndex()
    00995         {
    00996             m_executionContext.setCurrentStackFrameIndex(m_savedIndex);
    00997         }
    00998
    00999     private:
    01000
    01001         StylesheetExecutionContext&     m_executionContext;
    01002
    01003         const int                       m_savedIndex;
    01004     };
    01005
    01006     /*
    01007      * A class to manage stack state during execution.
    01008      */
    01009     class ParamsPushPop : public PushAndPopContextMarker
    01010     {
    01011     public:
    01012
    01013         ParamsPushPop(
    01014                 StylesheetExecutionContext&     executionContext,
    01015                 const ElemTemplateElement&      xslCallTemplateElement) :
    01016             PushAndPopContextMarker(executionContext)
    01017         {
    01018             doPush(xslCallTemplateElement);
    01019         }
    01020
    01021         ParamsPushPop(
    01022                 StylesheetExecutionContext&     executionContext,
    01023                 const ElemTemplateElement&      xslCallTemplateElement,
    01024                 int&                            savedStackFrameIndex) :
    01025             PushAndPopContextMarker(executionContext, savedStackFrameIndex)
    01026         {
    01027             doPush(
    01028                 xslCallTemplateElement,
    01029                 savedStackFrameIndex);
    01030         }
    01031
    01032         ~ParamsPushPop()
    01033         {
    01034         }
    01035
    01036     private:
    01037
    01038         void
    01039         doPush(
    01040             const ElemTemplateElement&      xslCallTemplateElement,
    01041             int                             stackFrameIndex);
    01042
    01043         void
    01044         doPush(const ElemTemplateElement&   xslCallTemplateElement);
    01045     };
    01046
    01056     virtual void
    01057     startDocument() = 0;
    01058
    01070     virtual void
    01071     endDocument() = 0;
    01072
    01078     virtual void
    01079     startElement(const XalanDOMChar*    name) = 0;
    01080
    01086     virtual void
    01087     endElement(const XalanDOMChar*  name) = 0;
    01088
    01096     virtual void
    01097     characters(
    01098             const XalanDOMChar*         ch,
    01099             XalanDOMString::size_type   start,
    01100             XalanDOMString::size_type   length) = 0;
    01101
    01111     virtual void
    01112     charactersRaw(
    01113             const XalanDOMChar*         ch,
    01114             XalanDOMString::size_type   start,
    01115             XalanDOMString::size_type   length) = 0;
    01116
    01122     virtual void
    01123     comment(const XalanDOMChar*     data) = 0;
    01124
    01131     virtual void
    01132     processingInstruction(
    01133             const XalanDOMChar*     target,
    01134             const XalanDOMChar*     data) = 0;
    01135
    01139     virtual void
    01140     flushPending() = 0;
    01141
    01148     virtual void
    01149     cloneToResultTree(
    01150             const XalanNode&    node,
    01151             const LocatorType*  locator) = 0;
    01152
    01163     virtual void
    01164     cloneToResultTree(
    01165             const XalanNode&        node,
    01166             XalanNode::NodeType     nodeType,
    01167             bool                    isLiteral,
    01168             bool                    overrideStrip,
    01169             bool                    shouldCloneAttributes,
    01170             const LocatorType*      locator) = 0;
    01171
    01179     virtual const XObjectPtr
    01180     createXResultTreeFrag(
    01181             const ElemTemplateElement&  templateChild,
    01182             XalanNode*                  sourceNode) = 0;
    01183
    01191     virtual void
    01192     outputToResultTree(
    01193             const XObject&      xobj,
    01194             const LocatorType*  locator) = 0;
    01195
    01203     virtual void
    01204     outputResultTreeFragment(
    01205             const XObject&      theTree,
    01206             const LocatorType*  locator) = 0;
    01207
    01213     virtual const XalanDOMString&
    01214     getXSLNameSpaceURL() const = 0;
    01215
    01221     virtual const XalanDOMString&
    01222     getXalanXSLNameSpaceURL() const = 0;
    01223
    01229     virtual bool
    01230     findOnElementRecursionStack(const ElemTemplateElement*  theElement) const = 0;
    01231
    01237     virtual void
    01238     pushOnElementRecursionStack(const ElemTemplateElement*  theElement) = 0;
    01239
    01245     virtual const ElemTemplateElement*
    01246     popElementRecursionStack() = 0;
    01247
    01251     class ElementRecursionStackPusher
    01252     {
    01253     public:
    01254
    01261         ElementRecursionStackPusher(
    01262                     StylesheetExecutionContext&     executionContext,
    01263                     const ElemTemplateElement*      element) :
    01264             m_executionContext(executionContext)
    01265         {
    01266             m_executionContext.pushOnElementRecursionStack(element);
    01267         }
    01268
    01269         ~ElementRecursionStackPusher()
    01270         {
    01271             m_executionContext.popElementRecursionStack();
    01272         }
    01273
    01274     private:
    01275
    01276         StylesheetExecutionContext&         m_executionContext;
    01277     };
    01278
    01279
    01289     virtual bool
    01290     returnXResultTreeFrag(XResultTreeFrag*  theXResultTreeFrag) = 0;
    01291
    01292
    01293     enum eDummy
    01294     {
    01295         eDefaultXMLIndentAmount = 0,
    01296         eDefaultHTMLIndentAmount = 0
    01297     };
    01298
    01302     enum eEscapeURLs
    01303     {
    01304         eEscapeURLsDefault,     // Use the value in the stylesheet
    01305         eEscapeURLsNo,          // Don't escape URLs
    01306         eEscapeURLsYes          // Escape URLs
    01307     };
    01308
    01316     virtual eEscapeURLs
    01317     getEscapeURLs() const = 0;
    01318
    01326     virtual void
    01327     setEscapeURLs(eEscapeURLs   value) = 0;
    01328
    01329
    01333     enum eOmitMETATag
    01334     {
    01335         eOmitMETATagDefault,    // Use the value in the stylesheet
    01336         eOmitMETATagNo,         // Don't omit the META tag
    01337         eOmitMETATagYes         // Omit the META tag
    01338     };
    01339
    01347     virtual eOmitMETATag
    01348     getOmitMETATag() const = 0;
    01349
    01357     virtual void
    01358     setOmitMETATag(eOmitMETATag     value) = 0;
    01359
    01380     virtual FormatterListener*
    01381     createFormatterToXML(
    01382             Writer&                 writer,
    01383             const XalanDOMString&   version = XalanDOMString(),
    01384             bool                    doIndent = false,
    01385             int                     indent = eDefaultXMLIndentAmount,
    01386             const XalanDOMString&   encoding = XalanDOMString(),
    01387             const XalanDOMString&   mediaType = XalanDOMString(),
    01388             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01389             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01390             bool                    xmlDecl = true,
    01391             const XalanDOMString&   standalone = XalanDOMString()) = 0;
    01392
    01410     virtual FormatterListener*
    01411     createFormatterToHTML(
    01412             Writer&                 writer,
    01413             const XalanDOMString&   encoding = XalanDOMString(),
    01414             const XalanDOMString&   mediaType = XalanDOMString(),
    01415             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01416             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01417             bool                    doIndent = true,
    01418             int                     indent = eDefaultHTMLIndentAmount,
    01419             bool                    escapeURLs = true,
    01420             bool                    omitMetaTag = false) = 0;
    01421
    01428     virtual FormatterListener*
    01429     createFormatterToText(
    01430             Writer&                 writer,
    01431             const XalanDOMString&   encoding) = 0;
    01432
    01433     class BorrowReturnFormatterToText
    01434     {
    01435     public:
    01436
    01437         BorrowReturnFormatterToText(
    01438                 StylesheetExecutionContext&     executionContext,
    01439                 Writer&                         writer,
    01440                 bool                            normalizeLinefeed = true,
    01441                 bool                            handleIgnorableWhitespace = true);
    01442
    01443         ~BorrowReturnFormatterToText()
    01444         {
    01445             assert(m_formatter != 0);
    01446
    01447             m_executionContext.returnFormatterToText(m_formatter);
    01448         }
    01449
    01450         FormatterToText&
    01451         operator*() const
    01452         {
    01453             assert(m_formatter != 0);
    01454
    01455             return *m_formatter;
    01456         }
    01457
    01458         FormatterToText*
    01459         get() const
    01460         {
    01461             assert(m_formatter != 0);
    01462
    01463             return m_formatter;
    01464         }
    01465
    01466         FormatterToText*
    01467         operator->() const
    01468         {
    01469             return get();
    01470         }
    01471
    01472     private:
    01473
    01474         StylesheetExecutionContext&     m_executionContext;
    01475
    01476         FormatterToText*                m_formatter;
    01477     };
    01478
    01479
    01480     friend class BorrowReturnFormatterToText;
    01481
    01487     virtual NodeSorter*
    01488     borrowNodeSorter() = 0;
    01489
    01496     virtual bool
    01497     returnNodeSorter(NodeSorter*    theSorter) = 0;
    01498
    01499     class BorrowReturnNodeSorter
    01500     {
    01501     public:
    01502
    01503         BorrowReturnNodeSorter(StylesheetExecutionContext&  executionContext) :
    01504             m_executionContext(executionContext),
    01505             m_sorter(executionContext.borrowNodeSorter())
    01506         {
    01507             assert(m_sorter != 0);
    01508         }
    01509
    01510         ~BorrowReturnNodeSorter()
    01511         {
    01512             assert(m_sorter != 0);
    01513
    01514             m_executionContext.returnNodeSorter(m_sorter);
    01515         }
    01516
    01517         NodeSorter&
    01518         operator*() const
    01519         {
    01520             assert(m_sorter != 0);
    01521
    01522             return *m_sorter;
    01523         }
    01524
    01525         NodeSorter*
    01526         get() const
    01527         {
    01528             assert(m_sorter != 0);
    01529
    01530             return m_sorter;
    01531         }
    01532
    01533         NodeSorter*
    01534         operator->() const
    01535         {
    01536             return get();
    01537         }
    01538
    01539     private:
    01540
    01541         StylesheetExecutionContext&     m_executionContext;
    01542
    01543         NodeSorter*                     m_sorter;
    01544     };
    01545
    01546
    01547     typedef XalanAutoPtr<XalanNumberFormat>     XalanNumberFormatAutoPtr;
    01548
    01555     virtual XalanNumberFormatAutoPtr
    01556     createXalanNumberFormat() = 0;
    01557
    01558
    01559     // Trace interface...
    01560
    01566     virtual size_type
    01567     getTraceListeners() const = 0;
    01568
    01574     virtual void
    01575     fireGenerateEvent(const GenerateEvent&  ge) = 0;
    01576
    01582     virtual void
    01583     fireTraceEvent(const TracerEvent&   te) = 0;
    01584
    01590     virtual void
    01591     fireSelectEvent(const SelectionEvent&   se) = 0;
    01592
    01598     virtual bool
    01599     getTraceSelects() const = 0;
    01600
    01608     virtual void
    01609     traceSelect(
    01610             const ElemTemplateElement&  theStylesheetElement,
    01611             const NodeRefListBase&      nl,
    01612             const XPath*                xpath) = 0;
    01613
    01623     virtual int
    01624     collationCompare(
    01625             const XalanDOMString&               theLHS,
    01626             const XalanDOMString&               theRHS,
    01627             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) = 0;
    01628
    01639     virtual int
    01640     collationCompare(
    01641             const XalanDOMString&               theLHS,
    01642             const XalanDOMString&               theRHS,
    01643             const XalanDOMString&               theLocale,
    01644             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) = 0;
    01645
    01655     virtual int
    01656     collationCompare(
    01657             const XalanDOMChar*                 theLHS,
    01658             const XalanDOMChar*                 theRHS,
    01659             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) = 0;
    01660
    01671     virtual int
    01672     collationCompare(
    01673             const XalanDOMChar*                 theLHS,
    01674             const XalanDOMChar*                 theRHS,
    01675             const XalanDOMChar*                 theLocale,
    01676             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) = 0;
    01677
    01684     virtual bool
    01685     getInConstruction(const KeyDeclaration&     keyDeclaration) const = 0;
    01686
    01692     virtual void
    01693     beginConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01694
    01700     virtual void
    01701     endConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01702
    01709     virtual PrintWriter*
    01710     createPrintWriter(XalanOutputStream*        theTextOutputStream) = 0;
    01711
    01720     virtual PrintWriter*
    01721     createPrintWriter(
    01722             const XalanDOMString&       theFileName,
    01723             const XalanDOMString&       theEncoding) = 0;
    01724
    01731     virtual PrintWriter*
    01732     createPrintWriter(StreamType&   theStream) = 0;
    01733
    01740     virtual PrintWriter*
    01741     createPrintWriter(FILE*     theStream) = 0;
    01742
    01749     virtual CountersTable&
    01750     getCountersTable() = 0;
    01751
    01757     virtual void
    01758     characters(const XalanNode&     node) = 0;
    01759
    01765     virtual void
    01766     characters(const XObjectPtr&    xobject) = 0;
    01767
    01774     virtual void
    01775     charactersRaw(const XalanNode&  node) = 0;
    01776
    01782     virtual void
    01783     charactersRaw(const XObjectPtr&     xobject) = 0;
    01784
    01785
    01786     // These interfaces are inherited from XPathExecutionContext...
    01787
    01788     virtual void
    01789     reset() = 0;
    01790
    01791     virtual XalanNode*
    01792     getCurrentNode() const = 0;
    01793
    01794     virtual void
    01795     pushCurrentNode(XalanNode*  theCurrentNode) = 0;
    01796
    01797     virtual void
    01798     popCurrentNode() = 0;
    01799
    01800     virtual bool
    01801     isNodeAfter(
    01802             const XalanNode&    node1,
    01803             const XalanNode&    node2) const = 0;
    01804
    01805     virtual void
    01806     pushContextNodeList(const NodeRefListBase&  theList) = 0;
    01807
    01808     virtual void
    01809     popContextNodeList() = 0;
    01810
    01811     virtual const NodeRefListBase&
    01812     getContextNodeList() const = 0;
    01813
    01814     virtual size_type
    01815     getContextNodeListLength() const = 0;
    01816
    01817     virtual size_type
    01818     getContextNodeListPosition(const XalanNode&     contextNode) const = 0;
    01819
    01827     virtual bool
    01828     elementAvailable(const XalanQName&  theQName) const = 0;
    01829
    01839     virtual bool
    01840     elementAvailable(
    01841             const XalanDOMString&   theName,
    01842             const LocatorType*      locator) const = 0;
    01843
    01851     virtual bool
    01852     functionAvailable(const XalanQName&     theQName) const = 0;
    01853
    01862     virtual bool
    01863     functionAvailable(
    01864             const XalanDOMString&   theName,
    01865             const LocatorType*      locator) const = 0;
    01866
    01867     virtual const XObjectPtr
    01868     extFunction(
    01869             const XalanDOMString&           theNamespace,
    01870             const XalanDOMString&           functionName,
    01871             XalanNode*                      context,
    01872             const XObjectArgVectorType&     argVec,
    01873             const LocatorType*              locator) = 0;
    01874
    01875     virtual XalanDocument*
    01876     parseXML(
    01877             const XalanDOMString&   urlString,
    01878             const XalanDOMString&   base) const = 0;
    01879
    01880     virtual MutableNodeRefList*
    01881     borrowMutableNodeRefList() = 0;
    01882
    01883     virtual bool
    01884     returnMutableNodeRefList(MutableNodeRefList*    theList) = 0;
    01885
    01886     virtual MutableNodeRefList*
    01887     createMutableNodeRefList() const = 0;
    01888
    01889     virtual XalanDOMString&
    01890     getCachedString() = 0;
    01891
    01892     virtual bool
    01893     releaseCachedString(XalanDOMString&     theString) = 0;
    01894
    01895     virtual void
    01896     getNodeSetByKey(
    01897             XalanDocument*          doc,
    01898             const XalanQName&       qname,
    01899             const XalanDOMString&   ref,
    01900             MutableNodeRefList&     nodelist) = 0;
    01901
    01902     virtual void
    01903     getNodeSetByKey(
    01904             XalanDocument*          doc,
    01905             const XalanDOMString&   name,
    01906             const XalanDOMString&   ref,
    01907             const LocatorType*      locator,
    01908             MutableNodeRefList&     nodelist) = 0;
    01909
    01910     virtual const XObjectPtr
    01911     getVariable(
    01912             const XalanQName&   name,
    01913             const LocatorType*  locator = 0) = 0;
    01914
    01915     virtual const PrefixResolver*
    01916     getPrefixResolver() const = 0;
    01917
    01918     virtual void
    01919     setPrefixResolver(const PrefixResolver*     thePrefixResolver) = 0;
    01920
    01921     virtual const XalanDOMString*
    01922     getNamespaceForPrefix(const XalanDOMString&     prefix) const = 0;
    01923
    01924     virtual XalanDOMString
    01925     findURIFromDoc(const XalanDocument*     owner) const = 0;
    01926
    01927     virtual const XalanDOMString&
    01928     getUnparsedEntityURI(
    01929             const XalanDOMString&   theName,
    01930             const XalanDocument&    theDocument) const = 0;
    01931
    01932     virtual bool
    01933     shouldStripSourceNode(const XalanNode&  node) = 0;
    01934
    01935     virtual XalanDocument*
    01936     getSourceDocument(const XalanDOMString&     theURI) const = 0;
    01937
    01938     virtual void
    01939     setSourceDocument(
    01940             const XalanDOMString&   theURI,
    01941             XalanDocument*          theDocument) = 0;
    01942
    01943
    01944     virtual const XalanDecimalFormatSymbols*
    01945     getDecimalFormatSymbols(const XalanQName&   qname) = 0;
    01946
    01947     // These interfaces are inherited from ExecutionContext...
    01948
    01949     virtual void
    01950     error(
    01951             const XalanDOMString&   msg,
    01952             const XalanNode*        sourceNode,
    01953             const LocatorType*      locator) const = 0;
    01954
    01955     virtual void
    01956     error(
    01957             const char*         msg,
    01958             const XalanNode*    sourceNode,
    01959             const LocatorType*  locator) const = 0;
    01960
    01961     virtual void
    01962     warn(
    01963             const XalanDOMString&   msg,
    01964             const XalanNode*        sourceNode = 0,
    01965             const LocatorType*      locator = 0) const = 0;
    01966
    01967     virtual void
    01968     warn(
    01969             const char*         msg,
    01970             const XalanNode*    sourceNode = 0,
    01971             const LocatorType*  locator = 0) const = 0;
    01972
    01973     virtual void
    01974     message(
    01975             const XalanDOMString&   msg,
    01976             const XalanNode*        sourceNode = 0,
    01977             const LocatorType*      locator = 0) const = 0;
    01978
    01979     virtual void
    01980     message(
    01981             const char*         msg,
    01982             const XalanNode*    sourceNode = 0,
    01983             const LocatorType*  locator = 0) const = 0;
    01984
    01985 protected:
    01986
    01992     virtual FormatterToText*
    01993     borrowFormatterToText() = 0;
    01994
    02001     virtual bool
    02002     returnFormatterToText(FormatterToText*  theFormatter) = 0;
    02003 };
    02004
    02005
    02006
    02007 XALAN_CPP_NAMESPACE_END
    02008
    02009
    02010
    02011 #endif  // STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680

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.7 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.