## Xalan-C++ API Documentation

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

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

# StylesheetExecutionContext.hpp

Go to the documentation of this file.

    00001 /*
    00002  * The Apache Software License, Version 1.1
    00003  *
    00004  *
    00005  * Copyright (c) 1999-2002 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 <XSLT/XSLTDefinitions.hpp>
    00066
    00067
    00068
    00069 #include <cstddef>
    00070 #include <memory>
    00071
    00072
    00073
    00074 // Base class header file...
    00075 #include <XPath/XPathExecutionContext.hpp>
    00076
    00077
    00078
    00079 #include <XalanDOM/XalanDOMString.hpp>
    00080
    00081
    00082
    00083 // Base class header file...
    00084 #include <PlatformSupport/ExecutionContext.hpp>
    00085
    00086
    00087
    00088 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
    00089 #include <PlatformSupport/XalanNumberFormat.hpp>
    00090 #endif
    00091
    00092
    00093
    00094 #include <Include/XalanAutoPtr.hpp>
    00095
    00096
    00097
    00098 #include <PlatformSupport/AttributeListImpl.hpp>
    00099
    00100
    00101
    00102 #include <XSLT/KeyTable.hpp>
    00103 #include <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 FormatterToDOM;
    00117 class FormatterToHTML;
    00118 class FormatterToText;
    00119 class FormatterToXML;
    00120 class GenerateEvent;
    00121 class KeyTable;
    00122 class PrefixResolver;
    00123 class NodeRefListBase;
    00124 class NodeSorter;
    00125 class PrintWriter;
    00126 class XalanQName;
    00127 class SelectionEvent;
    00128 class Stylesheet;
    00129 class StylesheetRoot;
    00130 class XalanOutputStream;
    00131 class TracerEvent;
    00132 class Writer;
    00133 class XalanDocument;
    00134 class XalanDocumentFragment;
    00135 class XalanElement;
    00136 class XalanNode;
    00137 class XalanNumberFormat;
    00138 class XPath;
    00139 class XObject;
    00140 class XObjectPtr;
    00141 class XResultTreeFrag;
    00142
    00143
    00144
    00145 //
    00146 // An abstract class which provides support for executing stylesheets.
    00147 //
    00148 class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext
    00149 {
    00150 public:
    00151
    00152 #if defined(XALAN_NO_STD_NAMESPACE)
    00153     typedef ostream         StreamType;
    00154 #else
    00155     typedef std::ostream    StreamType;
    00156 #endif
    00157
    00158     typedef size_t  size_type;
    00159
    00160     explicit
    00161     StylesheetExecutionContext(XObjectFactory*  theXObjectFactory = 0);
    00162
    00163     virtual
    00164     ~StylesheetExecutionContext();
    00165
    00166     // These interfaces are new...
    00167
    00175     virtual void
    00176     error(
    00177             const XalanDOMString&       msg,
    00178             const ElemTemplateElement&  styleNode,
    00179             const XalanNode*            sourceNode = 0) const = 0;
    00180
    00188     virtual void
    00189     error(
    00190             const char*                 msg,
    00191             const ElemTemplateElement&  styleNode,
    00192             const XalanNode*            sourceNode = 0) const = 0;
    00193
    00201     virtual void
    00202     warn(
    00203             const XalanDOMString&       msg,
    00204             const ElemTemplateElement&  styleNode,
    00205             const XalanNode*            sourceNode = 0) const = 0;
    00206
    00214     virtual void
    00215     warn(
    00216             const char*                 msg,
    00217             const ElemTemplateElement&  styleNode,
    00218             const XalanNode*            sourceNode = 0) const = 0;
    00219
    00227     virtual void
    00228     message(
    00229             const XalanDOMString&       msg,
    00230             const ElemTemplateElement&  styleNode,
    00231             const XalanNode*            sourceNode = 0) const = 0;
    00232
    00233
    00241     virtual void
    00242     message(
    00243             const char*                 msg,
    00244             const ElemTemplateElement&  styleNode,
    00245             const XalanNode*            sourceNode = 0) const = 0;
    00246
    00252     virtual bool
    00253     getQuietConflictWarnings() const = 0;
    00254
    00261     virtual bool
    00262     getCopyTextNodesOnly() const = 0;
    00263
    00270     virtual void
    00271     setCopyTextNodesOnly(bool   fValue) = 0;
    00272
    00273     /*
    00274      * A class to manage setting and restoring the flag
    00275      * for restricting copying only text nodes to the
    00276      * result tree
    00277      */
    00278     class SetAndRestoreCopyTextNodesOnly
    00279     {
    00280     public:
    00281
    00282         SetAndRestoreCopyTextNodesOnly(
    00283             StylesheetExecutionContext&     executionContext,
    00284             bool                            fValue) :
    00285             m_executionContext(executionContext),
    00286             m_fValue(executionContext.getCopyTextNodesOnly())
    00287         {
    00288             executionContext.setCopyTextNodesOnly(fValue);
    00289         }
    00290
    00291         ~SetAndRestoreCopyTextNodesOnly()
    00292         {
    00293             m_executionContext.setCopyTextNodesOnly(m_fValue);
    00294         }
    00295
    00296     private:
    00297
    00298         // Not implemented...
    00299         SetAndRestoreCopyTextNodesOnly(const SetAndRestoreCopyTextNodesOnly&);
    00300
    00301         SetAndRestoreCopyTextNodesOnly&
    00302         operator=(const SetAndRestoreCopyTextNodesOnly&);
    00303
    00304         // Data members...
    00305         StylesheetExecutionContext&     m_executionContext;
    00306
    00307         const bool                      m_fValue;
    00308     };
    00309
    00317     virtual XalanNode*
    00318     getRootDocument() const = 0;
    00319
    00327     virtual void
    00328     setRootDocument(XalanNode*  theDocument) = 0;
    00329
    00335     virtual XalanDocument*
    00336     createDocument() const = 0;
    00337
    00343     virtual void
    00344     setStylesheetRoot(const StylesheetRoot*     theStylesheet) = 0;
    00345
    00351     virtual const XalanQName*
    00352     getCurrentMode() const = 0;
    00353
    00359     virtual void
    00360     setCurrentMode(const XalanQName* theMode) = 0;
    00361
    00367     virtual const ElemTemplate*
    00368     getCurrentTemplate() const = 0;
    00369
    00375     virtual void
    00376     setCurrentTemplate(const ElemTemplate*  theTemplate) = 0;
    00377
    00378     /*
    00379      * A class to manage setting and restoring the current
    00380      * template instance.
    00381      */
    00382     class SetAndRestoreCurrentTemplate
    00383     {
    00384     public:
    00385
    00386         SetAndRestoreCurrentTemplate(
    00387             StylesheetExecutionContext&     executionContext,
    00388             const ElemTemplate*             theTemplate) :
    00389             m_executionContext(executionContext),
    00390             m_template(executionContext.getCurrentTemplate())
    00391         {
    00392             executionContext.setCurrentTemplate(theTemplate);
    00393         }
    00394
    00395         ~SetAndRestoreCurrentTemplate()
    00396         {
    00397             m_executionContext.setCurrentTemplate(m_template);
    00398         }
    00399
    00400     private:
    00401
    00402         // Not implemented...
    00403         SetAndRestoreCurrentTemplate(const SetAndRestoreCurrentTemplate&);
    00404
    00405         SetAndRestoreCurrentTemplate&
    00406         operator=(const SetAndRestoreCurrentTemplate&);
    00407
    00408         // Data members...
    00409         StylesheetExecutionContext&     m_executionContext;
    00410
    00411         const ElemTemplate* const       m_template;
    00412     };
    00413
    00419     virtual bool
    00420     doDiagnosticsOutput() const = 0;
    00421
    00427     virtual void
    00428     diag(const XalanDOMString&  theString) = 0;
    00429
    00436     virtual void
    00437     pushTime(const void*    theKey) = 0;
    00438
    00445     virtual void
    00446     displayDuration(
    00447             const XalanDOMString&   theMessage,
    00448             const void*             theKey) = 0;
    00449
    00453     virtual bool
    00454     isElementPending() const = 0;
    00455
    00463     virtual void
    00464     replacePendingAttribute(
    00465             const XalanDOMChar*     theName,
    00466             const XalanDOMChar*     theNewType,
    00467             const XalanDOMChar*     theNewValue) = 0;
    00468
    00474     virtual FormatterListener*
    00475     getFormatterListener() const = 0;
    00476
    00482     virtual void
    00483     setFormatterListener(FormatterListener*     flistener) = 0;
    00484
    00485     virtual void
    00486     pushOutputContext(FormatterListener*    flistener = 0) = 0;
    00487
    00488     virtual void
    00489     popOutputContext() = 0;
    00490
    00491     class OutputContextPushPop
    00492     {
    00493     public:
    00494
    00501         OutputContextPushPop(
    00502             StylesheetExecutionContext&     theExecutionContext,
    00503             FormatterListener*              theNewListener = 0) :
    00504             m_executionContext(theExecutionContext)
    00505         {
    00506             m_executionContext.pushOutputContext(theNewListener);
    00507         }
    00508
    00509         ~OutputContextPushPop()
    00510         {
    00511             m_executionContext.popOutputContext();
    00512         }
    00513
    00514     private:
    00515
    00516         StylesheetExecutionContext&     m_executionContext;
    00517     };
    00518
    00525     virtual void
    00526     addResultAttribute(
    00527             const XalanDOMString&   aname,
    00528             const XalanDOMString&   value) = 0;
    00529
    00536     virtual void
    00537     addResultAttribute(
    00538             const XalanDOMString&   aname,
    00539             const XalanDOMChar*     value) = 0;
    00540
    00546     virtual void
    00547     copyNamespaceAttributes(const XalanNode&    src) = 0;
    00548
    00556     virtual const XalanDOMString*
    00557     getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const = 0;
    00558
    00566     virtual const XalanDOMString*
    00567     getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const = 0;
    00568
    00577     virtual bool
    00578     isPendingResultPrefix(const XalanDOMString& thePrefix) = 0;
    00579
    00585     virtual XalanDOMString
    00586     getUniqueNamespaceValue() const = 0;
    00587
    00593     virtual void
    00594     getUniqueNamespaceValue(XalanDOMString&     theValue) const = 0;
    00595
    00601     virtual int
    00602     getIndent() const = 0;
    00603
    00609     virtual void
    00610     setIndent(int   indentAmount) = 0;
    00611
    00612     // $$$ ToDo: Remove this one!!!!
    00622 //  virtual const XObjectPtr
    00623 //  executeXPath(
    00624 //          const XalanDOMString&   str,
    00625 //          XalanNode*              contextNode,
    00626 //          const XalanElement&     resolver) = 0;
    00627
    00636     virtual const XPath*
    00637     createMatchPattern(
    00638             const XalanDOMString&   str,
    00639             const PrefixResolver&   resolver) = 0;
    00640
    00646     virtual void
    00647     returnXPath(const XPath*    xpath) = 0;
    00648
    00649     // A helper class to automatically return an XPath instance.
    00650     class XPathGuard
    00651     {
    00652     public:
    00653
    00654         XPathGuard(
    00655                 StylesheetExecutionContext&     context,
    00656                 const XPath*                    xpath = 0) :
    00657             m_context(context),
    00658             m_xpath(xpath)
    00659         {
    00660         }
    00661
    00662         ~XPathGuard()
    00663         {
    00664             if (m_xpath != 0)
    00665             {
    00666                 m_context.returnXPath(m_xpath);
    00667             }
    00668         }
    00669
    00670         const XPath*
    00671         get() const
    00672         {
    00673             return m_xpath;
    00674         }
    00675
    00676         const XPath*
    00677         release()
    00678         {
    00679             const XPath* const  temp = m_xpath;
    00680
    00681             m_xpath = 0;
    00682
    00683             return temp;
    00684         }
    00685
    00686         void
    00687         reset(const XPath*  xpath)
    00688         {
    00689             if (m_xpath != 0)
    00690             {
    00691                 m_context.returnXPath(m_xpath);
    00692             }
    00693
    00694             m_xpath = xpath;
    00695         }
    00696
    00697     private:
    00698
    00699         StylesheetExecutionContext&     m_context;
    00700
    00701         const XPath*                    m_xpath;
    00702     };
    00703
    00704 #if defined(XALAN_NO_STD_NAMESPACE)
    00705     typedef vector<TopLevelArg>         ParamVectorType;
    00706 #else
    00707     typedef std::vector<TopLevelArg>    ParamVectorType;
    00708 #endif
    00709
    00716     virtual void
    00717     pushTopLevelVariables(const ParamVectorType&    topLevelParams) = 0;
    00718
    00728     virtual const XObjectPtr
    00729     createVariable(
    00730             const XPath&                xpath,
    00731             XalanNode*                  contextNode,
    00732             const PrefixResolver&       resolver) = 0;
    00733
    00742     virtual const XObjectPtr
    00743     createVariable(
    00744             const ElemTemplateElement&  templateChild,
    00745             XalanNode*                  sourceNode) = 0;
    00746
    00759     virtual void
    00760     pushVariable(
    00761             const XalanQName&           name,
    00762             const ElemTemplateElement*  element,
    00763             const XalanDOMString&       str,
    00764             XalanNode*                  contextNode,
    00765             const PrefixResolver&       resolver) = 0;
    00766
    00778     virtual void
    00779     pushVariable(
    00780             const XalanQName&           name,
    00781             const ElemTemplateElement*  element,
    00782             const XPath&                xpath,
    00783             XalanNode*                  contextNode,
    00784             const PrefixResolver&       resolver) = 0;
    00785
    00795     virtual void
    00796     pushVariable(
    00797             const XalanQName&           name,
    00798             const ElemTemplateElement*  element,
    00799             const ElemTemplateElement&  templateChild,
    00800             XalanNode*                  sourceNode) = 0;
    00801
    00810     virtual void
    00811     pushVariable(
    00812             const XalanQName&           name,
    00813             const XObjectPtr            val,
    00814             const ElemTemplateElement*  element) = 0;
    00815
    00824     virtual void
    00825     pushVariable(
    00826             const XalanQName&           name,
    00827             const ElemVariable*         var,
    00828             const ElemTemplateElement*  element) = 0;
    00829
    00834     virtual void
    00835     pushContextMarker() = 0;
    00836
    00840     virtual void
    00841     popContextMarker() = 0;
    00842
    00843     /*
    00844      * A class to manage pushing and popping an element's stack
    00845      * frame context.
    00846      */
    00847     class PushAndPopContextMarker
    00848     {
    00849     public:
    00850
    00851         PushAndPopContextMarker(StylesheetExecutionContext&     executionContext) :
    00852             m_executionContext(executionContext)
    00853         {
    00854             executionContext.pushContextMarker();
    00855         }
    00856
    00857         ~PushAndPopContextMarker()
    00858         {
    00859             m_executionContext.popContextMarker();
    00860         }
    00861
    00862     private:
    00863
    00864         StylesheetExecutionContext&     m_executionContext;
    00865     };
    00866
    00870     virtual void
    00871     resolveTopLevelParams() = 0;
    00872
    00876     virtual void
    00877     clearTopLevelParams() = 0;
    00878
    00879     class ResolveAndClearTopLevelParams
    00880     {
    00881     public:
    00882
    00883         ResolveAndClearTopLevelParams(StylesheetExecutionContext&   executionContext) :
    00884             m_executionContext(executionContext)
    00885         {
    00886             m_executionContext.resolveTopLevelParams();
    00887         }
    00888
    00889         ~ResolveAndClearTopLevelParams()
    00890         {
    00891             m_executionContext.clearTopLevelParams();
    00892         }
    00893
    00894     private:
    00895
    00896         StylesheetExecutionContext&     m_executionContext;
    00897     };
    00898
    00907     virtual void
    00908     pushParams(
    00909             const ElemTemplateElement&  xslCallTemplateElement,
    00910             XalanNode*                  sourceNode,
    00911             const ElemTemplateElement*  targetTemplate) = 0;
    00912
    00920     virtual const XObjectPtr
    00921     getParamVariable(const XalanQName&  theName) = 0;
    00922
    00928     virtual void
    00929     pushElementFrame(const ElemTemplateElement*     elem) = 0;
    00930
    00936     virtual void
    00937     popElementFrame(const ElemTemplateElement*  elem) = 0;
    00938
    00939     /*
    00940      * A class to manage pushing and popping an element's stack
    00941      * frame context.
    00942      */
    00943     class PushAndPopElementFrame
    00944     {
    00945     public:
    00946
    00947         PushAndPopElementFrame(
    00948             StylesheetExecutionContext&     executionContext,
    00949             const ElemTemplateElement*      element) :
    00950             m_executionContext(executionContext),
    00951             m_element(element)
    00952         {
    00953             executionContext.pushElementFrame(element);
    00954         }
    00955
    00956         ~PushAndPopElementFrame()
    00957         {
    00958             m_executionContext.popElementFrame(m_element);
    00959         }
    00960
    00961     private:
    00962
    00963         StylesheetExecutionContext&     m_executionContext;
    00964
    00965         const ElemTemplateElement*      m_element;
    00966     };
    00967
    00973     virtual int
    00974     getGlobalStackFrameIndex() const = 0;
    00975
    00982     virtual int
    00983     getCurrentStackFrameIndex() const = 0;
    00984
    00991     virtual void
    00992     setCurrentStackFrameIndex(int   currentStackFrameIndex = -1) = 0;
    00993
    00994     /*
    00995      * A class to manage the state of the variable stacks frame index.
    00996      */
    00997     class SetAndRestoreCurrentStackFrameIndex
    00998     {
    00999     public:
    01000
    01001         SetAndRestoreCurrentStackFrameIndex(
    01002             StylesheetExecutionContext&     executionContext,
    01003             int                             newIndex) :
    01004             m_executionContext(executionContext),
    01005             m_savedIndex(executionContext.getCurrentStackFrameIndex())
    01006         {
    01007             executionContext.setCurrentStackFrameIndex(newIndex);
    01008         }
    01009
    01010         ~SetAndRestoreCurrentStackFrameIndex()
    01011         {
    01012             m_executionContext.setCurrentStackFrameIndex(m_savedIndex);
    01013         }
    01014
    01015         int
    01016         getStackFrameIndex() const
    01017         {
    01018             return m_savedIndex;
    01019         }
    01020
    01021     private:
    01022
    01023         StylesheetExecutionContext&     m_executionContext;
    01024
    01025         const int                       m_savedIndex;
    01026     };
    01027
    01028     /*
    01029      * A class to manage stack state during execution.
    01030      */
    01031     class ParamsPushPop
    01032     {
    01033     public:
    01034
    01035         ParamsPushPop(
    01036             StylesheetExecutionContext&     executionContext,
    01037             const ElemTemplateElement&      xslCallTemplateElement,
    01038             XalanNode*                      sourceNode,
    01039             const ElemTemplateElement*      targetTemplate);
    01040
    01041         ~ParamsPushPop();
    01042
    01043         int
    01044         getStackFrameIndex() const
    01045         {
    01046             return m_savedStackFrameIndex;
    01047         }
    01048
    01049     private:
    01050
    01051         StylesheetExecutionContext&     m_executionContext;
    01052
    01053         const int                       m_savedStackFrameIndex;
    01054     };
    01055
    01065     virtual void
    01066     startDocument() = 0;
    01067
    01079     virtual void
    01080     endDocument() = 0;
    01081
    01087     virtual void
    01088     startElement(const XalanDOMChar*    name) = 0;
    01089
    01095     virtual void
    01096     endElement(const XalanDOMChar*  name) = 0;
    01097
    01105     virtual void
    01106     characters(
    01107             const XalanDOMChar*         ch,
    01108             XalanDOMString::size_type   start,
    01109             XalanDOMString::size_type   length) = 0;
    01110
    01120     virtual void
    01121     charactersRaw(
    01122             const XalanDOMChar*         ch,
    01123             XalanDOMString::size_type   start,
    01124             XalanDOMString::size_type   length) = 0;
    01125
    01131     virtual void
    01132     comment(const XalanDOMChar*     data) = 0;
    01133
    01140     virtual void
    01141     processingInstruction(
    01142             const XalanDOMChar*     target,
    01143             const XalanDOMChar*     data) = 0;
    01144
    01148     virtual void
    01149     flushPending() = 0;
    01150
    01157     virtual void
    01158     cloneToResultTree(
    01159             const XalanNode&            node,
    01160             const ElemTemplateElement*  styleNode) = 0;
    01161
    01172     virtual void
    01173     cloneToResultTree(
    01174             const XalanNode&            node,
    01175             XalanNode::NodeType         nodeType,
    01176             bool                        isLiteral,
    01177             bool                        overrideStrip,
    01178             bool                        shouldCloneAttributes,
    01179             const ElemTemplateElement*  styleNode) = 0;
    01180
    01188     virtual const XObjectPtr
    01189     createXResultTreeFrag(
    01190             const ElemTemplateElement&  templateChild,
    01191             XalanNode*                  sourceNode) = 0;
    01192
    01200     virtual void
    01201     outputToResultTree(
    01202             const XObject&              xobj,
    01203             const ElemTemplateElement*  styleNode) = 0;
    01204
    01212     virtual void
    01213     outputResultTreeFragment(
    01214             const XObject&              theTree,
    01215             const ElemTemplateElement*  styleNode) = 0;
    01216
    01222     virtual const XalanDOMString&
    01223     getXSLNameSpaceURL() const = 0;
    01224
    01230     virtual const XalanDOMString&
    01231     getXalanXSLNameSpaceURL() const = 0;
    01232
    01238     virtual bool
    01239     findOnElementRecursionStack(const ElemTemplateElement*  theElement) const = 0;
    01240
    01246     virtual void
    01247     pushOnElementRecursionStack(const ElemTemplateElement*  theElement) = 0;
    01248
    01254     virtual const ElemTemplateElement*
    01255     popElementRecursionStack() = 0;
    01256
    01260     class ElementRecursionStackPusher
    01261     {
    01262     public:
    01263
    01270         ElementRecursionStackPusher(
    01271                     StylesheetExecutionContext&     executionContext,
    01272                     const ElemTemplateElement*      element) :
    01273             m_executionContext(executionContext)
    01274         {
    01275             m_executionContext.pushOnElementRecursionStack(element);
    01276         }
    01277
    01278         ~ElementRecursionStackPusher()
    01279         {
    01280             m_executionContext.popElementRecursionStack();
    01281         }
    01282
    01283     private:
    01284
    01285         StylesheetExecutionContext&         m_executionContext;
    01286     };
    01287
    01288
    01298     virtual bool
    01299     returnXResultTreeFrag(XResultTreeFrag*  theXResultTreeFrag) = 0;
    01300
    01301
    01302     enum eDummy
    01303     {
    01304         eDefaultXMLIndentAmount = 0,
    01305         eDefaultHTMLIndentAmount = 0
    01306     };
    01307
    01311     enum eEscapeURLs
    01312     {
    01313         eEscapeURLsDefault,     // Use the value in the stylesheet
    01314         eEscapeURLsNo,          // Don't escape URLs
    01315         eEscapeURLsYes          // Escape URLs
    01316     };
    01317
    01325     virtual eEscapeURLs
    01326     getEscapeURLs() const = 0;
    01327
    01335     virtual void
    01336     setEscapeURLs(eEscapeURLs   value) = 0;
    01337
    01338
    01342     enum eOmitMETATag
    01343     {
    01344         eOmitMETATagDefault,    // Use the value in the stylesheet
    01345         eOmitMETATagNo,         // Don't omit the META tag
    01346         eOmitMETATagYes         // Omit the META tag
    01347     };
    01348
    01356     virtual eOmitMETATag
    01357     getOmitMETATag() const = 0;
    01358
    01366     virtual void
    01367     setOmitMETATag(eOmitMETATag     value) = 0;
    01368
    01389     virtual FormatterToXML*
    01390     createFormatterToXML(
    01391             Writer&                 writer,
    01392             const XalanDOMString&   version = XalanDOMString(),
    01393             bool                    doIndent = false,
    01394             int                     indent = eDefaultXMLIndentAmount,
    01395             const XalanDOMString&   encoding = XalanDOMString(),
    01396             const XalanDOMString&   mediaType = XalanDOMString(),
    01397             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01398             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01399             bool                    xmlDecl = true,
    01400             const XalanDOMString&   standalone = XalanDOMString()) = 0;
    01401
    01419     virtual FormatterToHTML*
    01420     createFormatterToHTML(
    01421             Writer&                 writer,
    01422             const XalanDOMString&   encoding = XalanDOMString(),
    01423             const XalanDOMString&   mediaType = XalanDOMString(),
    01424             const XalanDOMString&   doctypeSystem = XalanDOMString(),
    01425             const XalanDOMString&   doctypePublic = XalanDOMString(),
    01426             bool                    doIndent = true,
    01427             int                     indent = eDefaultHTMLIndentAmount,
    01428             bool                    escapeURLs = true,
    01429             bool                    omitMetaTag = false) = 0;
    01430
    01439     virtual FormatterToDOM*
    01440     createFormatterToDOM(
    01441             XalanDocument*          doc,
    01442             XalanDocumentFragment*  docFrag,
    01443             XalanElement*           currentElement) = 0;
    01444
    01453     virtual FormatterToDOM*
    01454     createFormatterToDOM(
    01455             XalanDocument*  doc,
    01456             XalanElement*   elem) = 0;
    01457
    01464     virtual FormatterToText*
    01465     createFormatterToText(
    01466             Writer&                 writer,
    01467             const XalanDOMString&   encoding) = 0;
    01468
    01474     virtual FormatterToText*
    01475     borrowFormatterToText() = 0;
    01476
    01483     virtual bool
    01484     returnFormatterToText(FormatterToText*  theFormatter) = 0;
    01485
    01486     class BorrowReturnFormatterToText
    01487     {
    01488     public:
    01489
    01490         BorrowReturnFormatterToText(
    01491                 StylesheetExecutionContext&     executionContext,
    01492                 Writer&                         writer,
    01493                 bool                            normalizeLinefeed = true,
    01494                 bool                            handleIgnorableWhitespace = true);
    01495
    01496         ~BorrowReturnFormatterToText()
    01497         {
    01498             assert(m_formatter != 0);
    01499
    01500             m_executionContext.returnFormatterToText(m_formatter);
    01501         }
    01502
    01503         FormatterToText&
    01504         operator*() const
    01505         {
    01506             assert(m_formatter != 0);
    01507
    01508             return *m_formatter;
    01509         }
    01510
    01511         FormatterToText*
    01512         get() const
    01513         {
    01514             assert(m_formatter != 0);
    01515
    01516             return m_formatter;
    01517         }
    01518
    01519         FormatterToText*
    01520         operator->() const
    01521         {
    01522             return get();
    01523         }
    01524
    01525     private:
    01526
    01527         StylesheetExecutionContext&     m_executionContext;
    01528
    01529         FormatterToText*                m_formatter;
    01530     };
    01531
    01532
    01538     virtual NodeSorter*
    01539     borrowNodeSorter() = 0;
    01540
    01547     virtual bool
    01548     returnNodeSorter(NodeSorter*    theSorter) = 0;
    01549
    01550     class BorrowReturnNodeSorter
    01551     {
    01552     public:
    01553
    01554         BorrowReturnNodeSorter(StylesheetExecutionContext&  executionContext) :
    01555             m_executionContext(executionContext),
    01556             m_sorter(executionContext.borrowNodeSorter())
    01557         {
    01558             assert(m_sorter != 0);
    01559         }
    01560
    01561         ~BorrowReturnNodeSorter()
    01562         {
    01563             assert(m_sorter != 0);
    01564
    01565             m_executionContext.returnNodeSorter(m_sorter);
    01566         }
    01567
    01568         NodeSorter&
    01569         operator*() const
    01570         {
    01571             assert(m_sorter != 0);
    01572
    01573             return *m_sorter;
    01574         }
    01575
    01576         NodeSorter*
    01577         get() const
    01578         {
    01579             assert(m_sorter != 0);
    01580
    01581             return m_sorter;
    01582         }
    01583
    01584         NodeSorter*
    01585         operator->() const
    01586         {
    01587             return get();
    01588         }
    01589
    01590     private:
    01591
    01592         StylesheetExecutionContext&     m_executionContext;
    01593
    01594         NodeSorter*                     m_sorter;
    01595     };
    01596
    01597
    01598     typedef XalanAutoPtr<XalanNumberFormat>     XalanNumberFormatAutoPtr;
    01599
    01606     virtual XalanNumberFormatAutoPtr
    01607     createXalanNumberFormat() = 0;
    01608
    01609
    01610     // Trace interface...
    01611
    01617     virtual size_type
    01618     getTraceListeners() const = 0;
    01619
    01625     virtual void
    01626     fireGenerateEvent(const GenerateEvent&  ge) = 0;
    01627
    01633     virtual void
    01634     fireTraceEvent(const TracerEvent&   te) = 0;
    01635
    01641     virtual void
    01642     fireSelectEvent(const SelectionEvent&   se) = 0;
    01643
    01649     virtual bool
    01650     getTraceSelects() const = 0;
    01651
    01659     virtual void
    01660     traceSelect(
    01661             const ElemTemplateElement&  theStylesheetElement,
    01662             const NodeRefListBase&      nl,
    01663             const XPath*                xpath) = 0;
    01664
    01665     enum eCaseOrder { eDefault, eLowerFirst, eUpperFirst };
    01666
    01676     virtual int
    01677     collationCompare(
    01678             const XalanDOMString&   theLHS,
    01679             const XalanDOMString&   theRHS,
    01680             eCaseOrder              theCaseOrder = eDefault) = 0;
    01681
    01692     virtual int
    01693     collationCompare(
    01694             const XalanDOMString&   theLHS,
    01695             const XalanDOMString&   theRHS,
    01696             const XalanDOMString&   theLocale,
    01697             eCaseOrder              theCaseOrder = eDefault) = 0;
    01698
    01708     virtual int
    01709     collationCompare(
    01710             const XalanDOMChar*     theLHS,
    01711             const XalanDOMChar*     theRHS,
    01712             eCaseOrder              theCaseOrder = eDefault) = 0;
    01713
    01724     virtual int
    01725     collationCompare(
    01726             const XalanDOMChar*     theLHS,
    01727             const XalanDOMChar*     theRHS,
    01728             const XalanDOMChar*     theLocale,
    01729             eCaseOrder              theCaseOrder = eDefault) = 0;
    01730
    01737     virtual bool
    01738     getInConstruction(const KeyDeclaration&     keyDeclaration) const = 0;
    01739
    01745     virtual void
    01746     beginConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01747
    01753     virtual void
    01754     endConstruction(const KeyDeclaration& keyDeclaration) = 0;
    01755
    01762     virtual PrintWriter*
    01763     createPrintWriter(XalanOutputStream*        theTextOutputStream) = 0;
    01764
    01773     virtual PrintWriter*
    01774     createPrintWriter(
    01775             const XalanDOMString&       theFileName,
    01776             const XalanDOMString&       theEncoding) = 0;
    01777
    01784     virtual PrintWriter*
    01785     createPrintWriter(StreamType&   theStream) = 0;
    01786
    01793     virtual CountersTable&
    01794     getCountersTable() = 0;
    01795
    01801     virtual void
    01802     characters(const XalanNode&     node) = 0;
    01803
    01809     virtual void
    01810     characters(const XObjectPtr&    xobject) = 0;
    01811
    01818     virtual void
    01819     charactersRaw(const XalanNode&  node) = 0;
    01820
    01826     virtual void
    01827     charactersRaw(const XObjectPtr&     xobject) = 0;
    01828
    01829
    01830     // These interfaces are inherited from XPathExecutionContext...
    01831
    01832     virtual void
    01833     reset() = 0;
    01834
    01835     virtual XalanNode*
    01836     getCurrentNode() const = 0;
    01837
    01838     virtual void
    01839     setCurrentNode(XalanNode*   theCurrentNode) = 0;
    01840
    01841     virtual bool
    01842     isNodeAfter(
    01843             const XalanNode&    node1,
    01844             const XalanNode&    node2) const = 0;
    01845
    01846     virtual const NodeRefListBase&
    01847     getContextNodeList() const = 0;
    01848
    01849     virtual void
    01850     setContextNodeList(const NodeRefListBase&   theList) = 0;
    01851
    01852     virtual size_type
    01853     getContextNodeListLength() const = 0;
    01854
    01855     virtual size_type
    01856     getContextNodeListPosition(const XalanNode&     contextNode) const = 0;
    01857
    01865     virtual bool
    01866     elementAvailable(const XalanQName&  theQName) const = 0;
    01867
    01877     virtual bool
    01878     elementAvailable(
    01879             const XalanDOMString&   theName,
    01880             const LocatorType*      locator) const = 0;
    01881
    01889     virtual bool
    01890     functionAvailable(const XalanQName&     theQName) const = 0;
    01891
    01900     virtual bool
    01901     functionAvailable(
    01902             const XalanDOMString&   theName,
    01903             const LocatorType*      locator) const = 0;
    01904
    01905     virtual const XObjectPtr
    01906     extFunction(
    01907             const XalanDOMString&           theNamespace,
    01908             const XalanDOMString&           functionName,
    01909             XalanNode*                      context,
    01910             const XObjectArgVectorType&     argVec,
    01911             const LocatorType*              locator) = 0;
    01912
    01913     virtual XalanDocument*
    01914     parseXML(
    01915             const XalanDOMString&   urlString,
    01916             const XalanDOMString&   base) const = 0;
    01917
    01918     virtual MutableNodeRefList*
    01919     borrowMutableNodeRefList() = 0;
    01920
    01921     virtual bool
    01922     returnMutableNodeRefList(MutableNodeRefList*    theList) = 0;
    01923
    01924     virtual MutableNodeRefList*
    01925     createMutableNodeRefList() const = 0;
    01926
    01927     virtual XalanDOMString&
    01928     getCachedString() = 0;
    01929
    01930     virtual bool
    01931     releaseCachedString(XalanDOMString&     theString) = 0;
    01932
    01933     virtual void
    01934     getNodeSetByKey(
    01935             XalanDocument*          doc,
    01936             const XalanQName&       qname,
    01937             const XalanDOMString&   ref,
    01938             MutableNodeRefList&     nodelist) = 0;
    01939
    01940     virtual void
    01941     getNodeSetByKey(
    01942             XalanDocument*          doc,
    01943             const XalanDOMString&   name,
    01944             const XalanDOMString&   ref,
    01945             const LocatorType*      locator,
    01946             MutableNodeRefList&     nodelist) = 0;
    01947
    01948     virtual const XObjectPtr
    01949     getVariable(
    01950             const XalanQName&   name,
    01951             const LocatorType*  locator = 0) = 0;
    01952
    01953     virtual const PrefixResolver*
    01954     getPrefixResolver() const = 0;
    01955
    01956     virtual void
    01957     setPrefixResolver(const PrefixResolver*     thePrefixResolver) = 0;
    01958
    01959     virtual const XalanDOMString*
    01960     getNamespaceForPrefix(const XalanDOMString&     prefix) const = 0;
    01961
    01962     virtual XalanDOMString
    01963     findURIFromDoc(const XalanDocument*     owner) const = 0;
    01964
    01965     virtual const XalanDOMString&
    01966     getUnparsedEntityURI(
    01967             const XalanDOMString&   theName,
    01968             const XalanDocument&    theDocument) const = 0;
    01969
    01970     virtual bool
    01971     shouldStripSourceNode(const XalanNode&  node) = 0;
    01972
    01973     virtual bool
    01974     getThrowFoundIndex() const = 0;
    01975
    01976     virtual void
    01977     setThrowFoundIndex(bool     fThrow) = 0;
    01978
    01979     virtual XalanDocument*
    01980     getSourceDocument(const XalanDOMString&     theURI) const = 0;
    01981
    01982     virtual void
    01983     setSourceDocument(
    01984             const XalanDOMString&   theURI,
    01985             XalanDocument*          theDocument) = 0;
    01986
    01987
    01988     virtual const XalanDecimalFormatSymbols*
    01989     getDecimalFormatSymbols(const XalanQName&   qname) = 0;
    01990
    01991     // These interfaces are inherited from ExecutionContext...
    01992
    01993     virtual void
    01994     error(
    01995             const XalanDOMString&   msg,
    01996             const XalanNode*        sourceNode,
    01997             const LocatorType*      locator) const = 0;
    01998
    01999     virtual void
    02000     error(
    02001             const char*         msg,
    02002             const XalanNode*    sourceNode,
    02003             const LocatorType*  locator) const = 0;
    02004
    02005     virtual void
    02006     warn(
    02007             const XalanDOMString&   msg,
    02008             const XalanNode*        sourceNode = 0,
    02009             const LocatorType*      locator = 0) const = 0;
    02010
    02011     virtual void
    02012     warn(
    02013             const char*         msg,
    02014             const XalanNode*    sourceNode = 0,
    02015             const LocatorType*  locator = 0) const = 0;
    02016
    02017     virtual void
    02018     message(
    02019             const XalanDOMString&   msg,
    02020             const XalanNode*        sourceNode = 0,
    02021             const LocatorType*      locator = 0) const = 0;
    02022
    02023     virtual void
    02024     message(
    02025             const char*         msg,
    02026             const XalanNode*    sourceNode = 0,
    02027             const LocatorType*  locator = 0) const = 0;
    02028 };
    02029
    02030
    02031
    02032 XALAN_CPP_NAMESPACE_END
    02033
    02034
    02035
    02036 #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.5 Copyright © 2000, 2001, 2002, 2003 The Apache Software Foundation. All Rights Reserved.