Xalan-C++ API Documentation

The Xalan C++ XSL Transformer Version 1.1

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 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 #if defined(XALAN_OLD_STREAM_HEADERS)
00070 #include <iostream.h>
00071 #else
00072 #if defined(XALAN_NO_IOSFWD)
00073 #include <ostream>
00074 #else
00075 #include <iosfwd>
00076 #endif
00077 #endif
00078 
00079 
00080 
00081 #include <memory>
00082 
00083 
00084 
00085 // Base class header file...
00086 #include <XPath/XPathExecutionContext.hpp>
00087 
00088 
00089 
00090 #include <XalanDOM/XalanDOMString.hpp>
00091 
00092 
00093 
00094 // Base class header file...
00095 #include <PlatformSupport/ExecutionContext.hpp>
00096 
00097 
00098 
00099 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
00100 #include <PlatformSupport/XalanNumberFormat.hpp>
00101 #endif
00102 
00103 
00104 
00105 #include <Include/XalanAutoPtr.hpp>
00106 
00107 
00108 
00109 #include <PlatformSupport/AttributeListImpl.hpp>
00110 
00111 
00112 
00113 #include <XSLT/TopLevelArg.hpp>
00114 
00115 
00116 
00117 #include "KeyTable.hpp"
00118 
00119 
00120 
00121 class CountersTable;
00122 class ElemTemplateElement;
00123 class ElemVariable;
00124 class FormatterListener;
00125 class FormatterToDOM;
00126 class FormatterToHTML;
00127 class FormatterToText;
00128 class FormatterToXML;
00129 class GenerateEvent;
00130 class KeyTable;
00131 class PrefixResolver;
00132 class NodeRefListBase;
00133 class PrintWriter;
00134 class QName;
00135 class SelectionEvent;
00136 class Stylesheet;
00137 class StylesheetRoot;
00138 class XalanOutputStream;
00139 class TracerEvent;
00140 class Writer;
00141 class XalanDocument;
00142 class XalanDocumentFragment;
00143 class XalanElement;
00144 class XalanNode;
00145 class XalanNumberFormat;
00146 class XPath;
00147 class XObject;
00148 class XObjectPtr;
00149 
00150 
00151 
00152 //
00153 // An abstract class which provides support for executing stylesheets.
00154 //
00155 class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext
00156 {
00157 public:
00158 
00159     explicit
00160     StylesheetExecutionContext();
00161 
00162     virtual
00163     ~StylesheetExecutionContext();
00164 
00165     // These interfaces are new...
00166 
00172     virtual bool
00173     getQuietConflictWarnings() const = 0;
00174 
00182     virtual XalanNode*
00183     getRootDocument() const = 0;
00184 
00192     virtual void
00193     setRootDocument(XalanNode*  theDocument) = 0;
00194 
00200     virtual XalanDocument*
00201     createDocument() const = 0;
00202 
00208     virtual void
00209     setStylesheetRoot(const StylesheetRoot*     theStylesheet) = 0;
00210 
00217     virtual void
00218     resetCurrentState(
00219             XalanNode*  sourceTree,
00220             XalanNode*  xmlNode) = 0;
00221 
00227     virtual bool
00228     doDiagnosticsOutput() const = 0;
00229 
00235     virtual void
00236     diag(const XalanDOMString&  theString) = 0;
00237 
00244     virtual void
00245     pushTime(const void*    theKey) = 0;
00246 
00253     virtual void
00254     displayDuration(
00255             const XalanDOMString&   theMessage,
00256             const void*             theKey) = 0;
00257 
00261     virtual bool
00262     isElementPending() const = 0;
00263 
00271     virtual void
00272     replacePendingAttribute(
00273             const XalanDOMChar*     theName,
00274             const XalanDOMChar*     theNewType,
00275             const XalanDOMChar*     theNewValue) = 0;
00276 
00282     virtual FormatterListener*
00283     getFormatterListener() const = 0;
00284 
00290     virtual void
00291     setFormatterListener(FormatterListener*     flistener) = 0;
00292 
00293     virtual void
00294     pushOutputContext(FormatterListener*    flistener = 0) = 0;
00295 
00296     virtual void
00297     popOutputContext() = 0;
00298 
00299     class OutputContextPushPop
00300     {
00301     public:
00302 
00309         OutputContextPushPop(
00310             StylesheetExecutionContext&     theExecutionContext,
00311             FormatterListener*              theNewListener = 0) :
00312             m_executionContext(theExecutionContext)
00313         {
00314             m_executionContext.pushOutputContext(theNewListener);
00315         }
00316 
00317         ~OutputContextPushPop()
00318         {
00319             m_executionContext.popOutputContext();
00320         }
00321 
00322     private:
00323 
00324         StylesheetExecutionContext&     m_executionContext;
00325     };
00326 
00333     virtual void
00334     addResultAttribute(
00335             const XalanDOMString&   aname,
00336             const XalanDOMString&   value) = 0;
00337 
00343     virtual void
00344     copyNamespaceAttributes(const XalanNode&    src) = 0;
00345 
00351     virtual const XalanDOMString&
00352     getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const = 0;
00353 
00359     virtual const XalanDOMString&
00360     getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const = 0;
00361 
00367     virtual XalanDOMString
00368     getUniqueNamespaceValue() const = 0;
00369 
00375     virtual void
00376     getUniqueNamespaceValue(XalanDOMString&     theValue) const = 0;
00377 
00383     virtual int
00384     getIndent() const = 0;
00385 
00386     // $$$ ToDo: Remove this one!!!!
00396     virtual const XObjectPtr
00397     executeXPath(
00398             const XalanDOMString&   str,
00399             XalanNode*              contextNode,
00400             const XalanElement&     resolver) = 0;
00401 
00410     virtual const XPath*
00411     createMatchPattern(
00412             const XalanDOMString&   str,
00413             const PrefixResolver&   resolver) = 0;
00414 
00420     virtual void
00421     returnXPath(const XPath*    xpath) = 0;
00422 
00423     // A helper class to automatically return an XPath instance.
00424     class XPathGuard
00425     {
00426     public:
00427 
00428         XPathGuard(
00429                 StylesheetExecutionContext&     context,
00430                 const XPath*                    xpath = 0) :
00431             m_context(context),
00432             m_xpath(xpath)
00433         {
00434         }
00435 
00436         ~XPathGuard()
00437         {
00438             if (m_xpath != 0)
00439             {
00440                 m_context.returnXPath(m_xpath);
00441             }
00442         }
00443 
00444         const XPath*
00445         get() const
00446         {
00447             return m_xpath;
00448         }
00449 
00450         const XPath*
00451         release()
00452         {
00453             const XPath* const  temp = m_xpath;
00454 
00455             m_xpath = 0;
00456 
00457             return temp;
00458         }
00459 
00460         void
00461         reset(const XPath*  xpath)
00462         {
00463             if (m_xpath != 0)
00464             {
00465                 m_context.returnXPath(m_xpath);
00466             }
00467 
00468             m_xpath = xpath;
00469         }
00470 
00471     private:
00472 
00473         StylesheetExecutionContext&     m_context;
00474 
00475         const XPath*                    m_xpath;
00476     };
00477 
00486     virtual const XalanDOMString
00487     evaluateAttrVal(
00488             XalanNode*              contextNode,
00489             const PrefixResolver&   namespaceContext,
00490             const XalanDOMString&   stringedValue) = 0;
00491 
00492 #if defined(XALAN_NO_NAMESPACES)
00493     typedef vector<TopLevelArg>         ParamVectorType;
00494 #else
00495     typedef std::vector<TopLevelArg>    ParamVectorType;
00496 #endif
00497 
00504     virtual void
00505     pushTopLevelVariables(const ParamVectorType&    topLevelParams) = 0;
00506 
00517     virtual const XObjectPtr
00518     createVariable(
00519             const ElemTemplateElement*  element,
00520             const XPath&                xpath,
00521             XalanNode*                  contextNode,
00522             const PrefixResolver&       resolver) = 0;
00523 
00535     virtual const XObjectPtr
00536     createVariable(
00537             const ElemTemplateElement*  element,
00538             const ElemTemplateElement&  templateChild,
00539             XalanNode*                  sourceTree,
00540             XalanNode*                  sourceNode,
00541             const QName&                mode) = 0;
00542 
00555     virtual void
00556     pushVariable(
00557             const QName&                name,
00558             const ElemTemplateElement*  element,
00559             const XalanDOMString&       str,
00560             XalanNode*                  contextNode,
00561             const PrefixResolver&       resolver) = 0;
00562 
00574     virtual void
00575     pushVariable(
00576             const QName&                name,
00577             const ElemTemplateElement*  element,
00578             const XPath&                xpath,
00579             XalanNode*                  contextNode,
00580             const PrefixResolver&       resolver) = 0;
00581 
00592     virtual void
00593     pushVariable(
00594             const QName&                name,
00595             const ElemTemplateElement*  element,
00596             const ElemTemplateElement&  templateChild,
00597             XalanNode*                  sourceTree,
00598             XalanNode*                  sourceNode) = 0;
00599 
00608     virtual void
00609     pushVariable(
00610             const QName&                name,
00611             const XObjectPtr            val,
00612             const ElemTemplateElement*  element) = 0;
00613 
00622     virtual void
00623     pushVariable(
00624             const QName&                name,
00625             const ElemVariable*         var,
00626             const ElemTemplateElement*  element) = 0;
00627 
00632     virtual void
00633     pushContextMarker() = 0;
00634 
00638     virtual void
00639     popContextMarker() = 0;
00640 
00644     virtual void
00645     resolveTopLevelParams() = 0;
00646 
00650     virtual void
00651     clearTopLevelParams() = 0;
00652 
00663     virtual void
00664     pushParams(
00665             const ElemTemplateElement&  xslCallTemplateElement,
00666             XalanNode*                  sourceTree, 
00667             XalanNode*                  sourceNode,
00668             const QName&                mode,
00669             const ElemTemplateElement*  targetTemplate) = 0;
00670 
00678     virtual const XObjectPtr
00679     getParamVariable(const QName&   theName) = 0;
00680 
00686     virtual void
00687     pushElementFrame(const ElemTemplateElement*     elem) = 0;
00688 
00694     virtual void
00695     popElementFrame(const ElemTemplateElement*  elem) = 0;
00696 
00697     /*
00698      * A class to manage pushing and popping an element's stack
00699      * frame context.
00700      */
00701     class PushAndPopElementFrame
00702     {
00703     public:
00704 
00705         PushAndPopElementFrame(
00706             StylesheetExecutionContext&     executionContext,
00707             const ElemTemplateElement*      element) :
00708             m_executionContext(executionContext),
00709             m_element(element)
00710         {
00711             executionContext.pushElementFrame(element);
00712         }
00713 
00714         ~PushAndPopElementFrame()
00715         {
00716             m_executionContext.popElementFrame(m_element);
00717         }
00718 
00719     private:
00720 
00721         StylesheetExecutionContext&     m_executionContext;
00722 
00723         const ElemTemplateElement*      m_element;
00724     };
00725 
00732     virtual int
00733     getCurrentStackFrameIndex() const = 0;
00734 
00741     virtual void
00742     setCurrentStackFrameIndex(int   currentStackFrameIndex = -1) = 0;
00743 
00744     /*
00745      * A class to manage the state of the variable stacks frame index.
00746      */
00747     class SetAndRestoreCurrentStackFrameIndex
00748     {
00749     public:
00750 
00751         SetAndRestoreCurrentStackFrameIndex(
00752             StylesheetExecutionContext&     executionContext,
00753             int                             newIndex) :
00754             m_executionContext(executionContext),
00755             m_savedIndex(executionContext.getCurrentStackFrameIndex())
00756         {
00757             executionContext.setCurrentStackFrameIndex(newIndex);
00758         }
00759 
00760         ~SetAndRestoreCurrentStackFrameIndex()
00761         {
00762             m_executionContext.setCurrentStackFrameIndex(m_savedIndex);
00763         }
00764 
00765         int
00766         getStackFrameIndex() const
00767         {
00768             return m_savedIndex;
00769         }
00770 
00771     private:
00772 
00773         StylesheetExecutionContext&     m_executionContext;
00774 
00775         const int                       m_savedIndex;
00776     };
00777 
00778     /*
00779      * A class to manage stack state during execution.
00780      */
00781     class ParamsPushPop
00782     {
00783     public:
00784 
00785         ParamsPushPop(
00786             StylesheetExecutionContext&     executionContext,
00787             const ElemTemplateElement*      contextElement,
00788             const ElemTemplateElement&      xslCallTemplateElement,
00789             XalanNode*                      sourceTree, 
00790             XalanNode*                      sourceNode,
00791             const QName&                    mode,
00792             const ElemTemplateElement*      targetTemplate);
00793 
00794         ~ParamsPushPop();
00795 
00796         int
00797         getStackFrameIndex() const
00798         {
00799             return m_savedStackFrameIndex;
00800         }
00801 
00802     private:
00803 
00804         StylesheetExecutionContext&     m_executionContext;
00805     
00806         const int                       m_savedStackFrameIndex;
00807     };
00808 
00818     virtual void
00819     startDocument() = 0;
00820 
00832     virtual void
00833     endDocument() = 0;
00834 
00851     virtual void
00852     startElement(const XalanDOMChar*    name) = 0;
00853 
00868     virtual void
00869     endElement(const XalanDOMChar*  name) = 0;
00870 
00893     virtual void
00894     characters(
00895             const XalanDOMChar*     ch,
00896             unsigned int            start,
00897             unsigned int            length) = 0;
00898 
00909     virtual void
00910     charactersRaw(
00911             const XalanDOMChar*     ch,
00912             unsigned int            start,
00913             unsigned int            length) = 0;
00914 
00921     virtual void
00922     comment(const XalanDOMChar*     data) = 0;
00923 
00939     virtual void
00940     processingInstruction(
00941             const XalanDOMChar*     target,
00942             const XalanDOMChar*     data) = 0;
00943 
00947     virtual void
00948     flushPending() = 0;
00949 
00958     virtual void
00959     cloneToResultTree(
00960             XalanNode&  node, 
00961             bool        isLiteral,
00962             bool        overrideStrip,
00963             bool        shouldCloneAttributes) = 0;
00964 
00973     virtual const XObjectPtr
00974     createXResultTreeFrag(
00975             const ElemTemplateElement&  templateChild,
00976             XalanNode*                  sourceTree,
00977             XalanNode*                  sourceNode) = 0;
00978 
00988     virtual const XObjectPtr
00989     createXResultTreeFrag(
00990             const ElemTemplateElement&  templateChild,
00991             XalanNode*                  sourceTree,
00992             XalanNode*                  sourceNode,
00993             const QName&                mode) = 0;
00994 
01001     virtual void
01002     outputToResultTree(const XObject&   xobj) = 0;
01003 
01010     virtual void
01011     outputResultTreeFragment(const XObject&     theTree) = 0;
01012 
01018     virtual const XalanDOMString&
01019     getXSLNameSpaceURL() const = 0;
01020 
01026     virtual const XalanDOMString&
01027     getXalanXSLNameSpaceURL() const = 0;
01028 
01034     virtual bool
01035     findOnElementRecursionStack(const ElemTemplateElement*  theElement) const = 0;
01036 
01042     virtual void
01043     pushOnElementRecursionStack(const ElemTemplateElement*  theElement) = 0;
01044 
01050     virtual const ElemTemplateElement*
01051     popElementRecursionStack() = 0;
01052 
01056     class ElementRecursionStackPusher
01057     {
01058     public:
01059 
01066         ElementRecursionStackPusher(
01067                     StylesheetExecutionContext&     executionContext,
01068                     const ElemTemplateElement*      element) :
01069             m_executionContext(executionContext)
01070         {
01071             m_executionContext.pushOnElementRecursionStack(element);
01072         }
01073 
01074         ~ElementRecursionStackPusher()
01075         {
01076             m_executionContext.popElementRecursionStack();
01077         }
01078 
01079     private:
01080 
01081         StylesheetExecutionContext&         m_executionContext;
01082     };
01083 
01084 
01085     enum eDummy
01086     {
01087         eDefaultXMLIndentAmount = 0,
01088         eDefaultHTMLIndentAmount = 0
01089     };
01090 
01111     virtual FormatterToXML*
01112     createFormatterToXML(
01113             Writer&                 writer,
01114             const XalanDOMString&   version = XalanDOMString(),
01115             bool                    doIndent = false,
01116             int                     indent = eDefaultXMLIndentAmount,
01117             const XalanDOMString&   encoding = XalanDOMString(),
01118             const XalanDOMString&   mediaType = XalanDOMString(),
01119             const XalanDOMString&   doctypeSystem = XalanDOMString(),
01120             const XalanDOMString&   doctypePublic = XalanDOMString(),
01121             bool                    xmlDecl = true,
01122             const XalanDOMString&   standalone = XalanDOMString()) = 0;
01123 
01144     virtual FormatterToHTML*
01145     createFormatterToHTML(
01146             Writer&                 writer,
01147             const XalanDOMString&   encoding = XalanDOMString(),
01148             const XalanDOMString&   mediaType = XalanDOMString(),
01149             const XalanDOMString&   doctypeSystem = XalanDOMString(),
01150             const XalanDOMString&   doctypePublic = XalanDOMString(),
01151             bool                    doIndent = true,
01152             int                     indent = eDefaultHTMLIndentAmount,
01153             const XalanDOMString&   version = XalanDOMString(),
01154             const XalanDOMString&   standalone = XalanDOMString(),
01155             bool                    xmlDecl = false) = 0;
01156 
01165     virtual FormatterToDOM*
01166     createFormatterToDOM(
01167             XalanDocument*          doc,
01168             XalanDocumentFragment*  docFrag,
01169             XalanElement*           currentElement) = 0;
01170 
01179     virtual FormatterToDOM*
01180     createFormatterToDOM(
01181             XalanDocument*  doc,
01182             XalanElement*   elem) = 0;
01183 
01190     virtual FormatterToText*
01191     createFormatterToText(
01192             Writer&                 writer,
01193             const XalanDOMString&   encoding) = 0;
01194 
01195 
01196     typedef XalanAutoPtr<XalanNumberFormat>     XalanNumberFormatAutoPtr;
01197 
01204     virtual XalanNumberFormatAutoPtr
01205     createXalanNumberFormat() = 0;
01206 
01207 
01208     // Trace interface...
01209 
01215     virtual unsigned long
01216     getTraceListeners() const = 0;
01217 
01223     virtual void
01224     fireGenerateEvent(const GenerateEvent&  ge) = 0;
01225 
01231     virtual void
01232     fireTraceEvent(const TracerEvent&   te) = 0;
01233 
01239     virtual void
01240     fireSelectEvent(const SelectionEvent&   se) = 0;
01241 
01247     virtual bool
01248     getTraceSelects() const = 0;
01249 
01256     virtual void
01257     traceSelect(
01258             const XalanElement&     theTemplate,
01259             const NodeRefListBase&  nl) const = 0;
01260 
01269     virtual int
01270     collationCompare(
01271             const XalanDOMString&   theLHS,
01272             const XalanDOMString&   theRHS) = 0;
01273 
01282     virtual int
01283     collationCompare(
01284             const XalanDOMChar*     theLHS,
01285             const XalanDOMChar*     theRHS) = 0;
01286 
01293     virtual bool
01294     getInConstruction(const KeyDeclaration&     keyDeclaration) const = 0;
01295 
01301     virtual void
01302     beginConstruction(const KeyDeclaration& keyDeclaration) = 0; 
01303     
01309     virtual void
01310     endConstruction(const KeyDeclaration& keyDeclaration) = 0;
01311 
01318     virtual PrintWriter*
01319     createPrintWriter(XalanOutputStream*        theTextOutputStream) = 0;
01320 
01329     virtual PrintWriter*
01330     createPrintWriter(
01331             const XalanDOMString&       theFileName,
01332             const XalanDOMString&       theEncoding) = 0;
01333 
01340     virtual PrintWriter*
01341 #if defined(XALAN_NO_NAMESPACES)
01342     createPrintWriter(ostream&          theStream) = 0;
01343 #else
01344     createPrintWriter(std::ostream&     theStream) = 0;
01345 #endif
01346 
01353     virtual CountersTable&
01354     getCountersTable() = 0;
01355 
01356     // These interfaces are inherited from XPathExecutionContext...
01357 
01358     virtual void
01359     reset() = 0;
01360 
01361     virtual XalanNode*
01362     getCurrentNode() const = 0;
01363 
01364     virtual void
01365     setCurrentNode(XalanNode*   theCurrentNode) = 0;
01366 
01367     virtual XObjectFactory&
01368     getXObjectFactory() const = 0;
01369 
01370     virtual XObjectPtr
01371     createNodeSet(XalanNode&    theNode) = 0;
01372 
01373     virtual bool
01374     isNodeAfter(
01375             const XalanNode&    node1,
01376             const XalanNode&    node2) const = 0;
01377 
01378     virtual const NodeRefListBase&
01379     getContextNodeList() const = 0;
01380 
01381     virtual void    
01382     setContextNodeList(const NodeRefListBase&   theList) = 0;
01383 
01384     virtual unsigned int
01385     getContextNodeListLength() const = 0;
01386 
01387     virtual unsigned int
01388     getContextNodeListPosition(const XalanNode&     contextNode) const = 0;
01389 
01390     virtual bool
01391     elementAvailable(
01392             const XalanDOMString&   theNamespace, 
01393             const XalanDOMString&   elementName) const = 0;
01394 
01395     virtual bool
01396     functionAvailable(
01397             const XalanDOMString&   theNamespace, 
01398             const XalanDOMString&   functionName) const = 0;
01399 
01400     virtual const XObjectPtr
01401     extFunction(
01402             const XalanDOMString&           theNamespace,
01403             const XalanDOMString&           functionName,
01404             XalanNode*                      context,
01405             const XObjectArgVectorType&     argVec) = 0;
01406 
01407     virtual XLocator*
01408     getXLocatorFromNode(const XalanNode*    node) const = 0;
01409 
01410     virtual void
01411     associateXLocatorToNode(
01412             const XalanNode*    node,
01413             XLocator*           xlocator) = 0;
01414 
01415     virtual XalanDocument*
01416     parseXML(
01417             const XalanDOMString&   urlString,
01418             const XalanDOMString&   base) const = 0;
01419 
01420     virtual MutableNodeRefList*
01421     borrowMutableNodeRefList() = 0;
01422 
01423     virtual bool
01424     returnMutableNodeRefList(MutableNodeRefList*    theList) = 0;
01425 
01426     virtual ResultTreeFragBase*
01427     borrowResultTreeFrag() = 0;
01428 
01429     virtual bool
01430     returnResultTreeFrag(ResultTreeFragBase*    theResultTreeFragBase) = 0;
01431 
01432     virtual MutableNodeRefList*
01433     createMutableNodeRefList() const = 0;
01434 
01435     virtual XalanDOMString&
01436     getCachedString() = 0;
01437 
01438     virtual bool
01439     releaseCachedString(XalanDOMString&     theString) = 0;
01440 
01441     virtual void
01442     getNodeSetByKey(
01443             XalanNode*              doc,
01444             const XalanDOMString&   name,
01445             const XalanDOMString&   ref,
01446             const PrefixResolver&   resolver,
01447             MutableNodeRefList&     nodelist) = 0;
01448 
01449     virtual const XObjectPtr
01450     getVariable(const QName&    name) = 0;
01451 
01452     virtual const PrefixResolver*
01453     getPrefixResolver() const = 0;
01454 
01455     virtual void
01456     setPrefixResolver(const PrefixResolver*     thePrefixResolver) = 0;
01457 
01458     virtual const XalanDOMString&
01459     getNamespaceForPrefix(const XalanDOMString&     prefix) const = 0;
01460 
01461     virtual XalanDOMString
01462     findURIFromDoc(const XalanDocument*     owner) const = 0;
01463 
01464     virtual XalanDocument*
01465     getDOMFactory() const = 0;
01466 
01467     virtual const XalanDOMString&
01468     getUnparsedEntityURI(
01469             const XalanDOMString&   theName,
01470             const XalanDocument&    theDocument) const = 0;
01471 
01472     virtual bool
01473     shouldStripSourceNode(const XalanNode&  node) = 0;
01474 
01475     virtual bool
01476     getThrowFoundIndex() const = 0;
01477 
01478     virtual void
01479     setThrowFoundIndex(bool     fThrow) = 0;
01480 
01481     virtual XalanDocument*
01482     getSourceDocument(const XalanDOMString&     theURI) const = 0;
01483 
01484     virtual void
01485     setSourceDocument(
01486             const XalanDOMString&   theURI,
01487             XalanDocument*          theDocument) = 0;
01488 
01489 
01490     virtual const XalanDecimalFormatSymbols*
01491     getDecimalFormatSymbols(const XalanDOMString&   name) = 0;
01492 
01493     // These interfaces are inherited from ExecutionContext...
01494 
01495     virtual void
01496     error(
01497             const XalanDOMString&   msg,
01498             const XalanNode*        sourceNode = 0,
01499             const XalanNode*        styleNode = 0) const = 0;
01500 
01501     virtual void
01502     error(
01503             const char*         msg,
01504             const XalanNode*    sourceNode = 0,
01505             const XalanNode*    styleNode = 0) const = 0;
01506 
01507     virtual void
01508     warn(
01509             const XalanDOMString&   msg,
01510             const XalanNode*        sourceNode = 0,
01511             const XalanNode*        styleNode = 0) const = 0;
01512 
01513     virtual void
01514     warn(
01515             const char*         msg,
01516             const XalanNode*    sourceNode = 0,
01517             const XalanNode*    styleNode = 0) const = 0;
01518 
01519     virtual void
01520     message(
01521             const XalanDOMString&   msg,
01522             const XalanNode*        sourceNode = 0,
01523             const XalanNode*        styleNode = 0) const = 0;
01524 
01525     virtual void
01526     message(
01527             const char*         msg,
01528             const XalanNode*    sourceNode = 0,
01529             const XalanNode*    styleNode = 0) const = 0;
01530 };
01531 
01532 
01533 
01534 #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++ XSL Transformer Version 1.1
Copyright © 2000, 2001 The Apache Software Foundation. All Rights Reserved.