## Xalan-C++ API Documentation

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

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-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  * @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
    00101
    00102
    00103 #include <xalanc/XSLT/TopLevelArg.hpp>
    00104
    00105
    00106
    00107 XALAN_CPP_NAMESPACE_BEGIN
    00108
    00109
    00110
    00111 class CountersTable;
    00112 class ElemTemplate;
    00113 class ElemTemplateElement;
    00114 class ElemVariable;
    00115 class FormatterListener;
    00116 class FormatterToText;
    00117 class GenerateEvent;
    00118 class KeyDeclaration;
    00119 class PrefixResolver;
    00120 class NodeRefListBase;
    00121 class NodeSorter;
    00122 class PrintWriter;
    00123 class XalanQName;
    00124 class SelectionEvent;
    00125 class Stylesheet;
    00126 class StylesheetRoot;
    00127 class XalanOutputStream;
    00128 class TracerEvent;
    00129 class Writer;
    00130 class XalanDocument;
    00131 class XalanDocumentFragment;
    00132 class XalanElement;
    00133 class XalanNode;
    00134 class XalanNumberFormat;
    00135 class XPath;
    00136 class XObject;
    00137 class XObjectPtr;
    00138 class XResultTreeFrag;
    00139
    00140
    00141
    00142 //
    00143 // An abstract class which provides support for executing stylesheets.
    00144 //
    00145 class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext
    00146 {
    00147 public:
    00148
    00149 #if defined(XALAN_NO_STD_NAMESPACE)
    00150     typedef ostream         StreamType;
    00151 #else
    00152     typedef std::ostream    StreamType;
    00153 #endif
    00154
    00155     typedef size_t  size_type;
    00156
    00157     explicit
    00158     StylesheetExecutionContext(XObjectFactory*  theXObjectFactory = 0);
    00159
    00160     virtual
    00161     ~StylesheetExecutionContext();
    00162
    00163     // These interfaces are new...
    00164
    00172     virtual void
    00173     error(
    00174             const XalanDOMString&       msg,
    00175             const ElemTemplateElement&  styleNode,
    00176             const XalanNode*            sourceNode = 0) const = 0;
    00177
    00185     virtual void
    00186     error(
    00187             const char*                 msg,
    00188             const ElemTemplateElement&  styleNode,
    00189             const XalanNode*            sourceNode = 0) const = 0;
    00190
    00198     virtual void
    00199     warn(
    00200             const XalanDOMString&       msg,
    00201             const ElemTemplateElement&  styleNode,
    00202             const XalanNode*            sourceNode = 0) const = 0;
    00203
    00211     virtual void
    00212     warn(
    00213             const char*                 msg,
    00214             const ElemTemplateElement&  styleNode,
    00215             const XalanNode*            sourceNode = 0) const = 0;
    00216
    00224     virtual void
    00225     message(
    00226             const XalanDOMString&       msg,
    00227             const ElemTemplateElement&  styleNode,
    00228             const XalanNode*            sourceNode = 0) const = 0;
    00229
    00230
    00238     virtual void
    00239     message(
    00240             const char*                 msg,
    00241             const ElemTemplateElement&  styleNode,
    00242             const XalanNode*            sourceNode = 0) const = 0;
    00243
    00249     virtual bool
    00250     getQuietConflictWarnings() const = 0;
    00251
    00258     virtual bool
    00259     getCopyTextNodesOnly() const = 0;
    00260
    00267     virtual void
    00268     setCopyTextNodesOnly(bool   fValue) = 0;
    00269
    00270     /*
    00271      * A class to manage setting and restoring the flag
    00272      * for restricting copying only text nodes to the
    00273      * result tree
    00274      */
    00275     class SetAndRestoreCopyTextNodesOnly
    00276     {
    00277     public:
    00278
    00279         SetAndRestoreCopyTextNodesOnly(
    00280             StylesheetExecutionContext&     executionContext,
    00281             bool                            fValue) :
    00282             m_executionContext(executionContext),
    00283             m_fValue(executionContext.getCopyTextNodesOnly())
    00284         {
    00285             executionContext.setCopyTextNodesOnly(fValue);
    00286         }
    00287
    00288         ~SetAndRestoreCopyTextNodesOnly()
    00289         {
    00290             m_executionContext.setCopyTextNodesOnly(m_fValue);
    00291         }
    00292
    00293     private:
    00294
    00295         // Not implemented...
    00296         SetAndRestoreCopyTextNodesOnly(const SetAndRestoreCopyTextNodesOnly&);
    00297
    00298         SetAndRestoreCopyTextNodesOnly&
    00299         operator=(const SetAndRestoreCopyTextNodesOnly&);
    00300
    00301         // Data members...
    00302         StylesheetExecutionContext&     m_executionContext;
    00303
    00304         const bool                      m_fValue;
    00305     };
    00306
    00314     virtual XalanNode*
    00315     getRootDocument() const = 0;
    00316
    00324     virtual void
    00325     setRootDocument(XalanNode*  theDocument) = 0;
    00326
    00332     virtual XalanDocument*
    00333     createDocument() const = 0;
    00334
    00340     virtual void
    00341     setStylesheetRoot(const StylesheetRoot*     theStylesheet) = 0;
    00342
    00348     virtual const XalanQName*
    00349     getCurrentMode() const = 0;
    00350
    00356     virtual void
    00357     setCurrentMode(const XalanQName* theMode) = 0;
    00358
    00364     virtual const ElemTemplate*
    00365     getCurrentTemplate() const = 0;
    00366
    00372     virtual void
    00373     setCurrentTemplate(const ElemTemplate*  theTemplate) = 0;
    00374
    00375     /*
    00376      * A class to manage setting and restoring the current
    00377      * template instance.
    00378      */
    00379     class SetAndRestoreCurrentTemplate
    00380     {
    00381     public:
    00382
    00383         SetAndRestoreCurrentTemplate(
    00384             StylesheetExecutionContext&     executionContext,
    00385             const ElemTemplate*             theTemplate) :
    00386             m_executionContext(executionContext),
    00387             m_template(executionContext.getCurrentTemplate())
    00388         {
    00389             executionContext.setCurrentTemplate(theTemplate);
    00390         }
    00391
    00392         ~SetAndRestoreCurrentTemplate()
    00393         {
    00394             m_executionContext.setCurrentTemplate(m_template);
    00395         }
    00396
    00397     private:
    00398
    00399         // Not implemented...
    00400         SetAndRestoreCurrentTemplate(const SetAndRestoreCurrentTemplate&);
    00401
    00402         SetAndRestoreCurrentTemplate&
    00403         operator=(const SetAndRestoreCurrentTemplate&);
    00404
    00405         // Data members...
    00406         StylesheetExecutionContext&     m_executionContext;
    00407
    00408         const ElemTemplate* const       m_template;
    00409     };
    00410
    00416     virtual bool
    00417     doDiagnosticsOutput() const = 0;
    00418
    00424     virtual void
    00425     diag(const XalanDOMString&  theString) = 0;
    00426
    00433     virtual void
    00434     pushTime(const void*    theKey) = 0;
    00435
    00442     virtual void
    00443     displayDuration(
    00444             const XalanDOMString&   theMessage,
    00445             const void*             theKey) = 0;
    00446
    00450     virtual bool
    00451     isElementPending() const = 0;
    00452
    00460     virtual void
    00461     replacePendingAttribute(
    00462             const XalanDOMChar*     theName,
    00463             const XalanDOMChar*     theNewType,
    00464             const XalanDOMChar*     theNewValue) = 0;
    00465
    00471     virtual FormatterListener*
    00472     getFormatterListener() const = 0;
    00473
    00479     virtual void
    00480     setFormatterListener(FormatterListener*     flistener) = 0;
    00481
    00482     virtual void
    00483     pushOutputContext(FormatterListener*    flistener = 0) = 0;
    00484
    00485     virtual void
    00486     popOutputContext() = 0;
    00487
    00488     class OutputContextPushPop
    00489     {
    00490     public:
    00491
    00498         OutputContextPushPop(
    00499             StylesheetExecutionContext&     theExecutionContext,
    00500             FormatterListener*              theNewListener = 0) :
    00501             m_executionContext(theExecutionContext)
    00502         {
    00503             m_executionContext.pushOutputContext(theNewListener);
    00504         }
    00505
    00506         ~OutputContextPushPop()
    00507         {
    00508             m_executionContext.popOutputContext();
    00509         }
    00510
    00511     private:
    00512
    00513         StylesheetExecutionContext&     m_executionContext;
    00514     };
    00515
    00522     virtual void
    00523     addResultAttribute(
    00524             const XalanDOMString&   aname,
    00525             const XalanDOMString&   value) = 0;
    00526
    00533     virtual void
    00534     addResultAttribute(
    00535             const XalanDOMString&   aname,
    00536             const XalanDOMChar*     value) = 0;
    00537
    00543     virtual void
    00544     copyNamespaceAttributes(const XalanNode&    src) = 0;
    00545
    00553     virtual const XalanDOMString*
    00554     getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const = 0;
    00555
    00563     virtual const XalanDOMString*
    00564     getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const = 0;
    00565
    00574     virtual bool
    00575     isPendingResultPrefix(const XalanDOMString& thePrefix) = 0;
    00576
    00582     virtual XalanDOMString
    00583     getUniqueNamespaceValue() const = 0;
    00584
    00590     virtual void
    00591     getUniqueNamespaceValue(XalanDOMString&     theValue) const = 0;
    00592
    00598     virtual int
    00599     getIndent() const = 0;
    00600
    00606     virtual void
    00607     setIndent(int   indentAmount) = 0;
    00608
    00617     virtual const XPath*
    00618     createMatchPattern(
    00619             const XalanDOMString&   str,
    00620             const PrefixResolver&   resolver) = 0;
    00621
    00627     virtual void
    00628     returnXPath(const XPath*    xpath) = 0;
    00629
    00630     // A helper class to automatically return an XPath instance.
    00631     class XPathGuard
    00632     {
    00633     public:
    00634
    00635         XPathGuard(
    00636                 StylesheetExecutionContext&     context,
    00637                 const XPath*                    xpath = 0) :
    00638             m_context(context),
    00639             m_xpath(xpath)
    00640         {
    00641         }
    00642
    00643         ~XPathGuard()
    00644         {
    00645             if (m_xpath != 0)
    00646             {
    00647                 m_context.returnXPath(m_xpath);
    00648             }
    00649         }
    00650
    00651         const XPath*
    00652         get() const
    00653         {
    00654             return m_xpath;
    00655         }
    00656
    00657         const XPath*
    00658         release()
    00659         {
    00660             const XPath* const  temp = m_xpath;
    00661
    00662             m_xpath = 0;
    00663
    00664             return temp;
    00665         }
    00666
    00667         void
    00668         reset(const XPath*  xpath)
    00669         {
    00670             if (m_xpath != 0)
    00671             {
    00672                 m_context.returnXPath(m_xpath);
    00673             }
    00674
    00675             m_xpath = xpath;
    00676         }
    00677
    00678     private:
    00679
    00680         StylesheetExecutionContext&     m_context;
    00681
    00682         const XPath*                    m_xpath;
    00683     };
    00684
    00685 #if defined(XALAN_NO_STD_NAMESPACE)
    00686     typedef vector<TopLevelArg>         ParamVectorType;
    00687 #else
    00688     typedef std::vector<TopLevelArg>    ParamVectorType;
    00689 #endif
    00690
    00697     virtual void
    00698     pushTopLevelVariables(const ParamVectorType&    topLevelParams) = 0;
    00699
    00709     virtual const XObjectPtr
    00710     createVariable(
    00711             const XPath&                xpath,
    00712             XalanNode*                  contextNode,
    00713             const PrefixResolver&       resolver) = 0;
    00714
    00723     virtual const XObjectPtr
    00724     createVariable(
    00725             const ElemTemplateElement&  templateChild,
    00726             XalanNode*                  sourceNode) = 0;
    00727
    00740     virtual void
    00741     pushVariable(
    00742             const XalanQName&           name,
    00743             const ElemTemplateElement*  element,
    00744             const XalanDOMString&       str,
    00745             XalanNode*                  contextNode,
    00746             const PrefixResolver&       resolver) = 0;
    00747
    00759     virtual void
    00760     pushVariable(
    00761             const XalanQName&           name,
    00762             const ElemTemplateElement*  element,
    00763             const XPath&                xpath,
    00764             XalanNode*                  contextNode,
    00765             const PrefixResolver&       resolver) = 0;
    00766
    00776     virtual void
    00777     pushVariable(
    00778             const XalanQName&           name,
    00779             const ElemTemplateElement*  element,
    00780             const ElemTemplateElement&  templateChild,
    00781             XalanNode*                  sourceNode) = 0;
    00782
    00791     virtual void
    00792     pushVariable(
    00793             const XalanQName&           name,
    00794             const XObjectPtr            val,
    00795             const ElemTemplateElement*  element) = 0;
    00796
    00805     virtual void
    00806     pushVariable(
    00807             const XalanQName&           name,
    00808             const ElemVariable*         var,
    00809             const ElemTemplateElement*  element) = 0;
    00810
    00815     virtual void
    00816     pushContextMarker() = 0;
    00817
    00821     virtual void
    00822     popContextMarker() = 0;
    00823
    00824     /*
    00825      * A class to manage pushing and popping an element's stack
    00826      * frame context.
    00827      */
    00828     class PushAndPopContextMarker
    00829     {
    00830     public:
    00831
    00832         PushAndPopContextMarker(StylesheetExecutionContext&     executionContext) :
    00833             m_executionContext(executionContext)
    00834         {
    00835             executionContext.pushContextMarker();
    00836         }
    00837
    00838         ~PushAndPopContextMarker()
    00839         {
    00840             m_executionContext.popContextMarker();
    00841         }
    00842
    00843     private:
    00844
    00845         StylesheetExecutionContext&     m_executionContext;
    00846     };
    00847
    00851     virtual void
    00852     resolveTopLevelParams() = 0;
    00853
    00857     virtual void
    00858     clearTopLevelParams() = 0;
    00859
    00860     class ResolveAndClearTopLevelParams
    00861     {
    00862     public:
    00863
    00864         ResolveAndClearTopLevelParams(StylesheetExecutionContext&   executionContext) :
    00865             m_executionContext(executionContext)
    00866         {
    00867             m_executionContext.resolveTopLevelParams();
    00868         }
    00869
    00870         ~ResolveAndClearTopLevelParams()
    00871         {
    00872             m_executionContext.clearTopLevelParams();
    00873         }
    00874
    00875     private:
    00876
    00877         StylesheetExecutionContext&     m_executionContext;
    00878     };
    00879
    00888     virtual void
    00889     pushParams(
    00890             const ElemTemplateElement&  xslCallTemplateElement,
    00891             XalanNode*                  sourceNode,
    00892             const ElemTemplateElement*  targetTemplate) = 0;
    00893
    00901     virtual const XObjectPtr
    00902     getParamVariable(const XalanQName&  theName) = 0;
    00903
    00909     virtual void
    00910     pushElementFrame(const ElemTemplateElement*     elem) = 0;
    00911
    00917     virtual void
    00918     popElementFrame(const ElemTemplateElement*  elem) = 0;
    00919
    00920     /*
    00921      * A class to manage pushing and popping an element's stack
    00922      * frame context.
    00923      */
    00924     class PushAndPopElementFrame
    00925     {
    00926     public:
    00927
    00928         PushAndPopElementFrame(
    00929             StylesheetExecutionContext&     executionContext,
    00930             const ElemTemplateElement*      element) :
    00931             m_executionContext(executionContext),
    00932             m_element(element)
    00933         {
    00934             executionContext.pushElementFrame(element);
    00935         }
    00936
    00937         ~PushAndPopElementFrame()
    00938         {
    00939             m_executionContext.popElementFrame(m_element);
    00940         }
    00941
    00942     private:
    00943
    00944         StylesheetExecutionContext&     m_executionContext;
    00945
    00946         const ElemTemplateElement*      m_element;
    00947     };
    00948
    00954     virtual int
    00955     getGlobalStackFrameIndex() const = 0;
    00956
    00963     virtual int
    00964     getCurrentStackFrameIndex() const = 0;
    00965
    00972     virtual void
    00973     setCurrentStackFrameIndex(int   currentStackFrameIndex = -1) = 0;
    00974
    00975     /*
    00976      * A class to manage the state of the variable stacks frame index.
    00977      */
    00978     class SetAndRestoreCurrentStackFrameIndex
    00979     {
    00980     public:
    00981
    00982         SetAndRestoreCurrentStackFrameIndex(
    00983             StylesheetExecutionContext&     executionContext,
    00984             int                             newIndex) :
    00985             m_executionContext(executionContext),
    00986             m_savedIndex(executionContext.getCurrentStackFrameIndex())
    00987         {
    00988             executionContext.setCurrentStackFrameIndex(newIndex);
    00989         }
    00990
    00991         ~SetAndRestoreCurrentStackFrameIndex()
    00992         {
    00993             m_executionContext.setCurrentStackFrameIndex(m_savedIndex);
    00994         }
    00995
    00996         int
    00997         getStackFrameIndex() const
    00998         {
    00999             return m_savedIndex;
    01000         }
    01001
    01002     private:
    01003
    01004         StylesheetExecutionContext&     m_executionContext;
    01005
    01006         const int                       m_savedIndex;
    01007     };
    01008
    01009     /*
    01010      * A class to manage stack state during execution.
    01011      */
    01012     class ParamsPushPop
    01013     {
    01014     public:
    01015
    01016         ParamsPushPop(
    01017             StylesheetExecutionContext&     executionContext,
    01018             const ElemTemplateElement&      xslCallTemplateElement,
    01019             XalanNode*                      sourceNode,
    01020             const ElemTemplateElement*      targetTemplate);
    01021
    01022         ~ParamsPushPop();
    01023
    01024         int
    01025         getStackFrameIndex() const
    01026         {
    01027             return m_savedStackFrameIndex;
    01028         }
    01029
    01030     private:
    01031
    01032         StylesheetExecutionContext&     m_executionContext;
    01033
    01034         const int                       m_savedStackFrameIndex;
    01035     };
    01036
    01046     virtual void
    01047     startDocument() = 0;
    01048
    01060     virtual void
    01061     endDocument() = 0;
    01062
    01068     virtual void
    01069     startElement(const XalanDOMChar*    name) = 0;
    01070
    01076     virtual void
    01077     endElement(const XalanDOMChar*  name) = 0;
    01078
    01086     virtual void
    01087     characters(
    01088             const XalanDOMChar*         ch,
    01089             XalanDOMString::size_type   start,
    01090             XalanDOMString::size_type   length) = 0;
    01091
    01101     virtual void
    01102     charactersRaw(
    01103             const XalanDOMChar*         ch,
    01104             XalanDOMString::size_type   start,
    01105             XalanDOMString::size_type   length) = 0;
    01106
    01112     virtual void
    01113     comment(const XalanDOMChar*     data) = 0;
    01114
    01121     virtual void
    01122     processingInstruction(
    01123             const XalanDOMChar*     target,
    01124             const XalanDOMChar*     data) = 0;
    01125
    01129     virtual void
    01130     flushPending() = 0;
    01131
    01138     virtual void
    01139     cloneToResultTree(
    01140             const XalanNode&    node,
    01141             const LocatorType*  locator) = 0;
    01142
    01153     virtual void
    01154     cloneToResultTree(
    01155             const XalanNode&        node,
    01156             XalanNode::NodeType     nodeType,
    01157             bool                    isLiteral,
    01158             bool                    overrideStrip,
    01159             bool                    shouldCloneAttributes,
    01160             const LocatorType*      locator) = 0;
    01161
    01169     virtual const XObjectPtr
    01170     createXResultTreeFrag(
    01171             const ElemTemplateElement&  templateChild,
    01172             XalanNode*                  sourceNode) = 0;
    01173
    01181     virtual void
    01182     outputToResultTree(
    01183             const XObject&      xobj,
    01184             const LocatorType*  locator) = 0;
    01185
    01193     virtual void
    01194     outputResultTreeFragment(
    01195             const XObject&      theTree,
    01196             const LocatorType*  locator) = 0;
    01197
    01203     virtual const XalanDOMString&
    01204     getXSLNameSpaceURL() const = 0;
    01205
    01211     virtual const XalanDOMString&
    01212     getXalanXSLNameSpaceURL() const = 0;
    01213
    01219     virtual bool
    01220     findOnElementRecursionStack(const ElemTemplateElement*  theElement) const = 0;
    01221
    01227     virtual void
    01228     pushOnElementRecursionStack(const ElemTemplateElement*  theElement) = 0;
    01229
    01235     virtual const ElemTemplateElement*
    01236     popElementRecursionStack() = 0;
    01237
    01241     class ElementRecursionStackPusher
    01242     {
    01243     public:
    01244
    01251         ElementRecursionStackPusher(
    01252                     StylesheetExecutionContext&     executionContext,
    01253                     const ElemTemplateElement*      element) :
    01254             m_executionContext(executionContext)
    01255         {
    01256             m_executionContext.pushOnElementRecursionStack(element);
    01257         }
    01258
    01259         ~ElementRecursionStackPusher()
    01260         {
    01261             m_executionContext.popElementRecursionStack();
    01262         }
    01263
    01264     private:
    01265
    01266         StylesheetExecutionContext&         m_executionContext;
    01267     };
    01268
    01269
    01279     virtual bool
    01280     returnXResultTreeFrag(XResultTreeFrag*  theXResultTreeFrag) = 0;
    01281
    01282
    01283     enum eDummy
    01284     {
    01285         eDefaultXMLIndentAmount = 0,
    01286         eDefaultHTMLIndentAmount = 0
    01287     };
    01288
    01292     enum eEscapeURLs
    01293     {
    01294         eEscapeURLsDefault,     // Use the value in the stylesheet
    01295         eEscapeURLsNo,          // Don't escape URLs
    01296         eEscapeURLsYes          // Escape URLs
    01297     };
    01298
    01306     virtual eEscapeURLs
    01307     getEscapeURLs() const = 0;
    01308
    01316     virtual void
    01317     setEscapeURLs(eEscapeURLs   value) = 0;
    01318
    01319
    01323     enum eOmitMETATag
    01324     {
    01325         eOmitMETATagDefault,    // Use the value in the stylesheet
    01326         eOmitMETATagNo,         // Don't omit the META tag
    01327         eOmitMETATagYes         // Omit the META tag
    01328     };
    01329
    01337     virtual eOmitMETATag
    01338     getOmitMETATag() const = 0;
    01339
    01347     virtual void
    01348     setOmitMETATag(eOmitMETATag     value) = 0;
    01349
    01370     virtual FormatterListener*
    01371     createFormatterToXML(
    01372             Writer&                 writer,
    01373             const XalanDOMString&   version = XalanDOMString(),
    01374             bool                    doIndent = false,
    01375             int                     indent = eDefaultXMLIndentAmount,
    01376             const XalanDOMString&   encoding = XalanDOMString(),
    01377             const XalanDOMString&   mediaType = XalanDOMString(),
    01378             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01379             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01380             bool                    xmlDecl = true,
    01381             const XalanDOMString&   standalone = XalanDOMString()) = 0;
    01382
    01400     virtual FormatterListener*
    01401     createFormatterToHTML(
    01402             Writer&                 writer,
    01403             const XalanDOMString&   encoding = XalanDOMString(),
    01404             const XalanDOMString&   mediaType = XalanDOMString(),
    01405             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01406             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01407             bool                    doIndent = true,
    01408             int                     indent = eDefaultHTMLIndentAmount,
    01409             bool                    escapeURLs = true,
    01410             bool                    omitMetaTag = false) = 0;
    01411
    01418     virtual FormatterListener*
    01419     createFormatterToText(
    01420             Writer&                 writer,
    01421             const XalanDOMString&   encoding) = 0;
    01422
    01423     class BorrowReturnFormatterToText
    01424     {
    01425     public:
    01426
    01427         BorrowReturnFormatterToText(
    01428                 StylesheetExecutionContext&     executionContext,
    01429                 Writer&                         writer,
    01430                 bool                            normalizeLinefeed = true,
    01431                 bool                            handleIgnorableWhitespace = true);
    01432
    01433         ~BorrowReturnFormatterToText()
    01434         {
    01435             assert(m_formatter != 0);
    01436
    01437             m_executionContext.returnFormatterToText(m_formatter);
    01438         }
    01439
    01440         FormatterToText&
    01441         operator*() const
    01442         {
    01443             assert(m_formatter != 0);
    01444
    01445             return *m_formatter;
    01446         }
    01447
    01448         FormatterToText*
    01449         get() const
    01450         {
    01451             assert(m_formatter != 0);
    01452
    01453             return m_formatter;
    01454         }
    01455
    01456         FormatterToText*
    01457         operator->() const
    01458         {
    01459             return get();
    01460         }
    01461
    01462     private:
    01463
    01464         StylesheetExecutionContext&     m_executionContext;
    01465
    01466         FormatterToText*                m_formatter;
    01467     };
    01468
    01469
    01470     friend class BorrowReturnFormatterToText;
    01471
    01477     virtual NodeSorter*
    01478     borrowNodeSorter() = 0;
    01479
    01486     virtual bool
    01487     returnNodeSorter(NodeSorter*    theSorter) = 0;
    01488
    01489     class BorrowReturnNodeSorter
    01490     {
    01491     public:
    01492
    01493         BorrowReturnNodeSorter(StylesheetExecutionContext&  executionContext) :
    01494             m_executionContext(executionContext),
    01495             m_sorter(executionContext.borrowNodeSorter())
    01496         {
    01497             assert(m_sorter != 0);
    01498         }
    01499
    01500         ~BorrowReturnNodeSorter()
    01501         {
    01502             assert(m_sorter != 0);
    01503
    01504             m_executionContext.returnNodeSorter(m_sorter);
    01505         }
    01506
    01507         NodeSorter&
    01508         operator*() const
    01509         {
    01510             assert(m_sorter != 0);
    01511
    01512             return *m_sorter;
    01513         }
    01514
    01515         NodeSorter*
    01516         get() const
    01517         {
    01518             assert(m_sorter != 0);
    01519
    01520             return m_sorter;
    01521         }
    01522
    01523         NodeSorter*
    01524         operator->() const
    01525         {
    01526             return get();
    01527         }
    01528
    01529     private:
    01530
    01531         StylesheetExecutionContext&     m_executionContext;
    01532
    01533         NodeSorter*                     m_sorter;
    01534     };
    01535
    01536
    01537     typedef XalanAutoPtr<XalanNumberFormat>     XalanNumberFormatAutoPtr;
    01538
    01545     virtual XalanNumberFormatAutoPtr
    01546     createXalanNumberFormat() = 0;
    01547
    01548
    01549     // Trace interface...
    01550
    01556     virtual size_type
    01557     getTraceListeners() const = 0;
    01558
    01564     virtual void
    01565     fireGenerateEvent(const GenerateEvent&  ge) = 0;
    01566
    01572     virtual void
    01573     fireTraceEvent(const TracerEvent&   te) = 0;
    01574
    01580     virtual void
    01581     fireSelectEvent(const SelectionEvent&   se) = 0;
    01582
    01588     virtual bool
    01589     getTraceSelects() const = 0;
    01590
    01598     virtual void
    01599     traceSelect(
    01600             const ElemTemplateElement&  theStylesheetElement,
    01601             const NodeRefListBase&      nl,
    01602             const XPath*                xpath) = 0;
    01603
    01604     enum eCaseOrder { eDefault, eLowerFirst, eUpperFirst };
    01605
    01615     virtual int
    01616     collationCompare(
    01617             const XalanDOMString&   theLHS,
    01618             const XalanDOMString&   theRHS,
    01619             eCaseOrder              theCaseOrder = eDefault) = 0;
    01620
    01631     virtual int
    01632     collationCompare(
    01633             const XalanDOMString&   theLHS,
    01634             const XalanDOMString&   theRHS,
    01635             const XalanDOMString&   theLocale,
    01636             eCaseOrder              theCaseOrder = eDefault) = 0;
    01637
    01647     virtual int
    01648     collationCompare(
    01649             const XalanDOMChar*     theLHS,
    01650             const XalanDOMChar*     theRHS,
    01651             eCaseOrder              theCaseOrder = eDefault) = 0;
    01652
    01663     virtual int
    01664     collationCompare(
    01665             const XalanDOMChar*     theLHS,
    01666             const XalanDOMChar*     theRHS,
    01667             const XalanDOMChar*     theLocale,
    01668             eCaseOrder              theCaseOrder = eDefault) = 0;
    01669
    01676     virtual bool
    01677     getInConstruction(const KeyDeclaration&     keyDeclaration) const = 0;
    01678
    01684     virtual void
    01685     beginConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01686
    01692     virtual void
    01693     endConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01694
    01701     virtual PrintWriter*
    01702     createPrintWriter(XalanOutputStream*        theTextOutputStream) = 0;
    01703
    01712     virtual PrintWriter*
    01713     createPrintWriter(
    01714             const XalanDOMString&       theFileName,
    01715             const XalanDOMString&       theEncoding) = 0;
    01716
    01723     virtual PrintWriter*
    01724     createPrintWriter(StreamType&   theStream) = 0;
    01725
    01732     virtual PrintWriter*
    01733     createPrintWriter(FILE*     theStream) = 0;
    01734
    01741     virtual CountersTable&
    01742     getCountersTable() = 0;
    01743
    01749     virtual void
    01750     characters(const XalanNode&     node) = 0;
    01751
    01757     virtual void
    01758     characters(const XObjectPtr&    xobject) = 0;
    01759
    01766     virtual void
    01767     charactersRaw(const XalanNode&  node) = 0;
    01768
    01774     virtual void
    01775     charactersRaw(const XObjectPtr&     xobject) = 0;
    01776
    01777
    01778     // These interfaces are inherited from XPathExecutionContext...
    01779
    01780     virtual void
    01781     reset() = 0;
    01782
    01783     virtual XalanNode*
    01784     getCurrentNode() const = 0;
    01785
    01786     virtual void
    01787     setCurrentNode(XalanNode*   theCurrentNode) = 0;
    01788
    01789     virtual bool
    01790     isNodeAfter(
    01791             const XalanNode&    node1,
    01792             const XalanNode&    node2) const = 0;
    01793
    01794     virtual const NodeRefListBase&
    01795     getContextNodeList() const = 0;
    01796
    01797     virtual void
    01798     setContextNodeList(const NodeRefListBase&   theList) = 0;
    01799
    01800     virtual size_type
    01801     getContextNodeListLength() const = 0;
    01802
    01803     virtual size_type
    01804     getContextNodeListPosition(const XalanNode&     contextNode) const = 0;
    01805
    01813     virtual bool
    01814     elementAvailable(const XalanQName&  theQName) const = 0;
    01815
    01825     virtual bool
    01826     elementAvailable(
    01827             const XalanDOMString&   theName,
    01828             const LocatorType*      locator) const = 0;
    01829
    01837     virtual bool
    01838     functionAvailable(const XalanQName&     theQName) const = 0;
    01839
    01848     virtual bool
    01849     functionAvailable(
    01850             const XalanDOMString&   theName,
    01851             const LocatorType*      locator) const = 0;
    01852
    01853     virtual const XObjectPtr
    01854     extFunction(
    01855             const XalanDOMString&           theNamespace,
    01856             const XalanDOMString&           functionName,
    01857             XalanNode*                      context,
    01858             const XObjectArgVectorType&     argVec,
    01859             const LocatorType*              locator) = 0;
    01860
    01861     virtual XalanDocument*
    01862     parseXML(
    01863             const XalanDOMString&   urlString,
    01864             const XalanDOMString&   base) const = 0;
    01865
    01866     virtual MutableNodeRefList*
    01867     borrowMutableNodeRefList() = 0;
    01868
    01869     virtual bool
    01870     returnMutableNodeRefList(MutableNodeRefList*    theList) = 0;
    01871
    01872     virtual MutableNodeRefList*
    01873     createMutableNodeRefList() const = 0;
    01874
    01875     virtual XalanDOMString&
    01876     getCachedString() = 0;
    01877
    01878     virtual bool
    01879     releaseCachedString(XalanDOMString&     theString) = 0;
    01880
    01881     virtual void
    01882     getNodeSetByKey(
    01883             XalanDocument*          doc,
    01884             const XalanQName&       qname,
    01885             const XalanDOMString&   ref,
    01886             MutableNodeRefList&     nodelist) = 0;
    01887
    01888     virtual void
    01889     getNodeSetByKey(
    01890             XalanDocument*          doc,
    01891             const XalanDOMString&   name,
    01892             const XalanDOMString&   ref,
    01893             const LocatorType*      locator,
    01894             MutableNodeRefList&     nodelist) = 0;
    01895
    01896     virtual const XObjectPtr
    01897     getVariable(
    01898             const XalanQName&   name,
    01899             const LocatorType*  locator = 0) = 0;
    01900
    01901     virtual const PrefixResolver*
    01902     getPrefixResolver() const = 0;
    01903
    01904     virtual void
    01905     setPrefixResolver(const PrefixResolver*     thePrefixResolver) = 0;
    01906
    01907     virtual const XalanDOMString*
    01908     getNamespaceForPrefix(const XalanDOMString&     prefix) const = 0;
    01909
    01910     virtual XalanDOMString
    01911     findURIFromDoc(const XalanDocument*     owner) const = 0;
    01912
    01913     virtual const XalanDOMString&
    01914     getUnparsedEntityURI(
    01915             const XalanDOMString&   theName,
    01916             const XalanDocument&    theDocument) const = 0;
    01917
    01918     virtual bool
    01919     shouldStripSourceNode(const XalanNode&  node) = 0;
    01920
    01921     virtual bool
    01922     getThrowFoundIndex() const = 0;
    01923
    01924     virtual void
    01925     setThrowFoundIndex(bool     fThrow) = 0;
    01926
    01927     virtual XalanDocument*
    01928     getSourceDocument(const XalanDOMString&     theURI) const = 0;
    01929
    01930     virtual void
    01931     setSourceDocument(
    01932             const XalanDOMString&   theURI,
    01933             XalanDocument*          theDocument) = 0;
    01934
    01935
    01936     virtual const XalanDecimalFormatSymbols*
    01937     getDecimalFormatSymbols(const XalanQName&   qname) = 0;
    01938
    01939     // These interfaces are inherited from ExecutionContext...
    01940
    01941     virtual void
    01942     error(
    01943             const XalanDOMString&   msg,
    01944             const XalanNode*        sourceNode,
    01945             const LocatorType*      locator) const = 0;
    01946
    01947     virtual void
    01948     error(
    01949             const char*         msg,
    01950             const XalanNode*    sourceNode,
    01951             const LocatorType*  locator) const = 0;
    01952
    01953     virtual void
    01954     warn(
    01955             const XalanDOMString&   msg,
    01956             const XalanNode*        sourceNode = 0,
    01957             const LocatorType*      locator = 0) const = 0;
    01958
    01959     virtual void
    01960     warn(
    01961             const char*         msg,
    01962             const XalanNode*    sourceNode = 0,
    01963             const LocatorType*  locator = 0) const = 0;
    01964
    01965     virtual void
    01966     message(
    01967             const XalanDOMString&   msg,
    01968             const XalanNode*        sourceNode = 0,
    01969             const LocatorType*      locator = 0) const = 0;
    01970
    01971     virtual void
    01972     message(
    01973             const char*         msg,
    01974             const XalanNode*    sourceNode = 0,
    01975             const LocatorType*  locator = 0) const = 0;
    01976
    01977 protected:
    01978
    01984     virtual FormatterToText*
    01985     borrowFormatterToText() = 0;
    01986
    01993     virtual bool
    01994     returnFormatterToText(FormatterToText*  theFormatter) = 0;
    01995 };
    01996
    01997
    01998
    01999 XALAN_CPP_NAMESPACE_END
    02000
    02001
    02002
    02003 #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.6 Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.