Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

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

StylesheetExecutionContextDefault.hpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 1999-2004 The Apache Software Foundation.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #if !defined(STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
00017 #define STYLESHEETEXECUTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
00018 
00019 
00020 
00021 // Base class include file.
00022 #include <xalanc/XSLT/StylesheetExecutionContext.hpp>
00023 
00024 
00025 
00026 #include <ctime>
00027 #include <deque>
00028 #include <memory>
00029 #include <set>
00030 #include <vector>
00031 
00032 
00033 
00034 #include <xalanc/Include/XalanObjectCache.hpp>
00035 
00036 
00037 
00038 #include <xalanc/XPath/XPathExecutionContextDefault.hpp>
00039 
00040 
00041 
00042 #include <xalanc/XMLSupport/FormatterToText.hpp>
00043 
00044 
00045 
00046 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
00047 #include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp>
00048 #endif
00049 #include <xalanc/XalanSourceTree/FormatterToSourceTree.hpp>
00050 #include <xalanc/XalanSourceTree/XalanSourceTreeDocumentFragment.hpp>
00051 
00052 
00053 
00054 #include <xalanc/XSLT/CountersTable.hpp>
00055 #include <xalanc/XSLT/NodeSorter.hpp>
00056 #include <xalanc/XSLT/Stylesheet.hpp>
00057 #include <xalanc/XSLT/VariablesStack.hpp>
00058 #include <xalanc/XSLT/XResultTreeFragAllocator.hpp>
00059 #include <xalanc/XSLT/XalanSourceTreeDocumentAllocator.hpp>
00060 #include <xalanc/XSLT/XalanSourceTreeDocumentFragmentAllocator.hpp>
00061 
00062 
00063 
00064 XALAN_CPP_NAMESPACE_BEGIN
00065 
00066 
00067 
00068 class XalanSourceTreeDocument;
00069 class XPathProcessor;
00070 class XSLTEngineImpl;
00071 
00072 
00073 
00074 //
00075 // An class which provides support for executing stylesheets.
00076 //
00077 class XALAN_XSLT_EXPORT StylesheetExecutionContextDefault : public StylesheetExecutionContext
00078 {
00079 public:
00080 
00081 #if defined(XALAN_STRICT_ANSI_HEADERS)
00082     typedef std::clock_t    ClockType;
00083 #else
00084     typedef clock_t         ClockType;
00085 #endif
00086 
00087 #if defined(XALAN_NO_STD_NAMESPACE)
00088     typedef deque<const ElemTemplateElement*>           ElementTemplateElementStackType;
00089     typedef vector<FormatterListener*>                  FormatterListenerVectorType;
00090     typedef vector<PrintWriter*>                        PrintWriterVectorType;
00091     typedef vector<XalanOutputStream*>                  OutputStreamVectorType;
00092     typedef set<const KeyDeclaration*,
00093                 less<const KeyDeclaration*> >           KeyDeclarationSetType;
00094     typedef pair<const XPath*, ClockType>               XPathCacheEntry;
00095     typedef map<XalanDOMString,
00096                 XPathCacheEntry,
00097                 less<XalanDOMString> >                  XPathCacheMapType;
00098     typedef deque<const ElemTemplate*>                  CurrentTemplateStackType;
00099 #else
00100     typedef std::deque<const ElemTemplateElement*>      ElementTemplateElementStackType;
00101     typedef std::vector<FormatterListener*>             FormatterListenerVectorType;
00102     typedef std::vector<PrintWriter*>                   PrintWriterVectorType;
00103     typedef std::vector<XalanOutputStream*>             OutputStreamVectorType;
00104     typedef std::set<const KeyDeclaration*>             KeyDeclarationSetType;
00105     typedef std::pair<const XPath*, ClockType>          XPathCacheEntry;
00106     typedef std::map<XalanDOMString, XPathCacheEntry>   XPathCacheMapType;
00107     typedef std::deque<const ElemTemplate*>             CurrentTemplateStackType;
00108 #endif
00109 
00110     typedef Stylesheet::KeyTablesTableType              KeyTablesTableType;
00111     typedef VariablesStack::ParamsVectorType            ParamsVectorType;
00112 
00113 
00124     StylesheetExecutionContextDefault(
00125             XSLTEngineImpl&         xsltProcessor,
00126             XPathEnvSupport&        theXPathEnvSupport,
00127             DOMSupport&             theDOMSupport,
00128             XObjectFactory&         theXObjectFactory,
00129             XalanNode*              theCurrentNode = 0,
00130             const NodeRefListBase*  theContextNodeList = 0,
00131             const PrefixResolver*   thePrefixResolver = 0);
00132 
00143     explicit
00144     StylesheetExecutionContextDefault(
00145             XalanNode*              theCurrentNode = 0,
00146             const NodeRefListBase*  theContextNodeList = 0,
00147             const PrefixResolver*   thePrefixResolver = 0);
00148 
00149     virtual
00150     ~StylesheetExecutionContextDefault();
00151 
00152 
00158     void
00159     setXPathEnvSupport(XPathEnvSupport*     theSupport)
00160     {
00161         m_xpathExecutionContextDefault.setXPathEnvSupport(theSupport);
00162     }
00163 
00169     void
00170     setDOMSupport(DOMSupport*   theDOMSupport)
00171     {
00172         m_xpathExecutionContextDefault.setDOMSupport(theDOMSupport);
00173     }
00174 
00180     void
00181     setXObjectFactory(XObjectFactory*   theXObjectFactory)
00182     {
00183         m_xpathExecutionContextDefault.setXObjectFactory(theXObjectFactory);
00184 
00185         m_xobjectFactory = theXObjectFactory;
00186     }
00187 
00188 
00194     void
00195     setXSLTProcessor(XSLTEngineImpl*    theProcessor)
00196     {
00197         m_xsltProcessor = theProcessor;
00198     }
00199 
00200     bool
00201     getUsePerInstanceDocumentFactory() const
00202     {
00203         return m_usePerInstanceDocumentFactory;
00204     }
00205 
00206     void
00207     setUsePerInstanceDocumentFactory(bool   fValue)
00208     {
00209         m_usePerInstanceDocumentFactory = fValue;
00210     }
00211 
00212 
00213     // These interfaces are inherited from StylesheetExecutionContext...
00214 
00215     virtual void
00216     error(
00217             const XalanDOMString&       msg,
00218             const ElemTemplateElement&  styleNode,
00219             const XalanNode*            sourceNode = 0) const;
00220 
00221     virtual void
00222     error(
00223             const char*                 msg,
00224             const ElemTemplateElement&  styleNode,
00225             const XalanNode*            sourceNode = 0) const;
00226 
00227     virtual void
00228     warn(
00229             const XalanDOMString&       msg,
00230             const ElemTemplateElement&  styleNode,
00231             const XalanNode*            sourceNode = 0) const;
00232 
00233     virtual void
00234     warn(
00235             const char*                 msg,
00236             const ElemTemplateElement&  styleNode,
00237             const XalanNode*            sourceNode = 0) const;
00238 
00239     virtual void
00240     message(
00241             const XalanDOMString&       msg,
00242             const ElemTemplateElement&  styleNode,
00243             const XalanNode*            sourceNode = 0) const;
00244 
00245     virtual void
00246     message(
00247             const char*                 msg,
00248             const ElemTemplateElement&  styleNode,
00249             const XalanNode*            sourceNode = 0) const;
00250 
00251     virtual bool
00252     getQuietConflictWarnings() const;
00253 
00254     virtual bool
00255     getCopyTextNodesOnly() const;
00256 
00257     virtual void
00258     setCopyTextNodesOnly(bool   fValue);
00259 
00260     virtual XalanNode*
00261     getRootDocument() const;
00262 
00263     virtual void
00264     setRootDocument(XalanNode*  theDocument);
00265 
00266     virtual void
00267     setStylesheetRoot(const StylesheetRoot*     theStylesheet);
00268 
00269     virtual const XalanQName*
00270     getCurrentMode() const;
00271 
00272     virtual void
00273     setCurrentMode(const XalanQName*    theMode); 
00274 
00275     virtual const ElemTemplate*
00276     getCurrentTemplate() const;
00277 
00278     virtual void
00279     pushCurrentTemplate(const ElemTemplate* theTemplate);
00280 
00281     virtual void
00282     popCurrentTemplate();
00283 
00284     virtual bool
00285     doDiagnosticsOutput() const;
00286 
00287     virtual void
00288     diag(const XalanDOMString&  theString);
00289 
00290     virtual void
00291     pushTime(const void*    theKey);
00292 
00293     virtual void
00294     displayDuration(
00295             const XalanDOMString&   theMessage,
00296             const void*             theKey);
00297 
00298     virtual bool
00299     isElementPending() const;
00300 
00301     virtual void
00302     replacePendingAttribute(
00303             const XalanDOMChar*     theName,
00304             const XalanDOMChar*     theNewType,
00305             const XalanDOMChar*     theNewValue);
00306 
00307     virtual void
00308     pushOutputContext(FormatterListener*    flistener = 0);
00309 
00310     virtual void
00311     popOutputContext();
00312 
00313     virtual void
00314     addResultAttribute(
00315             const XalanDOMString&   aname,
00316             const XalanDOMString&   value);
00317 
00318     virtual void
00319     addResultAttribute(
00320             const XalanDOMString&   aname,
00321             const XalanDOMChar*     value);
00322 
00323     virtual void
00324     copyNamespaceAttributes(const XalanNode&    src);
00325 
00326     virtual const XalanDOMString*
00327     getResultPrefixForNamespace(const XalanDOMString&   theNamespace) const;
00328 
00329     virtual const XalanDOMString*
00330     getResultNamespaceForPrefix(const XalanDOMString&   thePrefix) const;
00331 
00332     virtual bool
00333     isPendingResultPrefix(const XalanDOMString& thePrefix);
00334 
00335     virtual XalanDOMString
00336     getUniqueNamespaceValue() const;
00337 
00338     virtual void
00339     getUniqueNamespaceValue(XalanDOMString&     theValue) const;
00340 
00341     virtual FormatterListener*
00342     getFormatterListener() const;
00343 
00344     virtual void
00345     setFormatterListener(FormatterListener*     flistener);
00346 
00347     virtual int
00348     getIndent() const;
00349 
00350     virtual void
00351     setIndent(int   indentAmount);
00352 
00353     virtual const XPath*
00354     createMatchPattern(
00355             const XalanDOMString&   str,
00356             const PrefixResolver&   resolver);
00357 
00358     virtual void
00359     returnXPath(const XPath*    xpath);
00360 
00361     virtual void
00362     pushTopLevelVariables(const ParamVectorType&    topLevelParams);
00363 
00364     virtual const XObjectPtr
00365     createVariable(
00366             const XPath&                xpath,
00367             XalanNode*                  contextNode,
00368             const PrefixResolver&       resolver);
00369 
00370     virtual const XObjectPtr
00371     createVariable(
00372             const ElemTemplateElement&  templateChild,
00373             XalanNode*                  sourceNode);
00374 
00375     virtual void
00376     pushVariable(
00377             const XalanQName&           name,
00378             const ElemTemplateElement*  element,
00379             const XalanDOMString&       str,
00380             XalanNode*                  contextNode,
00381             const PrefixResolver&       resolver);
00382 
00383     virtual void
00384     pushVariable(
00385             const XalanQName&           name,
00386             const XObjectPtr            val,
00387             const ElemTemplateElement*  element);
00388 
00389     virtual void
00390     pushVariable(
00391             const XalanQName&           name,
00392             const ElemVariable*         var,
00393             const ElemTemplateElement*  element);
00394 
00395     virtual void
00396     pushVariable(
00397             const XalanQName&           name,
00398             const ElemTemplateElement*  element,
00399             const XPath&                xpath,
00400             XalanNode*                  contextNode,
00401             const PrefixResolver&       resolver);
00402 
00403     virtual void
00404     pushVariable(
00405             const XalanQName&           name,
00406             const ElemTemplateElement*  element,
00407             const ElemTemplateElement&  templateChild,
00408             XalanNode*                  sourceNode);
00409 
00410     virtual void
00411     pushContextMarker();
00412 
00413     virtual void
00414     popContextMarker();
00415 
00416     virtual void
00417     resolveTopLevelParams();
00418 
00419     virtual void
00420     clearTopLevelParams();
00421 
00422     virtual void
00423     pushParams(const ElemTemplateElement&   xslCallTemplateElement);
00424 
00425     virtual const XObjectPtr
00426     getParamVariable(const XalanQName&  theName);
00427 
00428     virtual void
00429     pushElementFrame(const ElemTemplateElement*     elem);
00430 
00431     virtual void
00432     popElementFrame();
00433 
00434     virtual int
00435     getGlobalStackFrameIndex() const;
00436 
00437     virtual int
00438     getCurrentStackFrameIndex() const;
00439 
00440     virtual void
00441     setCurrentStackFrameIndex(int currentStackFrameIndex = -1);
00442 
00443     virtual void
00444     startDocument();
00445 
00446     virtual void
00447     endDocument();
00448 
00449     virtual void
00450     startElement(const XalanDOMChar*    name);
00451 
00452     virtual void
00453     endElement(const XalanDOMChar*  name);
00454 
00455     virtual void
00456     characters(
00457             const XalanDOMChar*         ch,
00458             XalanDOMString::size_type   start,
00459             XalanDOMString::size_type   length);
00460 
00461     virtual void
00462     charactersRaw(
00463             const XalanDOMChar*         ch,
00464             XalanDOMString::size_type   start,
00465             XalanDOMString::size_type   length);
00466 
00467     virtual void
00468     comment(const XalanDOMChar*     data);
00469 
00470     virtual void
00471     processingInstruction(
00472             const XalanDOMChar*     target,
00473             const XalanDOMChar*     data);
00474 
00475     virtual void
00476     flushPending();
00477 
00478     virtual void
00479     cloneToResultTree(
00480             const XalanNode&    node,
00481             const LocatorType*  locator);
00482 
00483     virtual void
00484     cloneToResultTree(
00485             const XalanNode&        node,
00486             XalanNode::NodeType     nodeType,
00487             bool                    overrideStrip,
00488             bool                    shouldCloneAttributes,
00489             const LocatorType*      locator);
00490 
00491     virtual const XObjectPtr
00492     createXResultTreeFrag(
00493             const ElemTemplateElement&  templateChild,
00494             XalanNode*                  sourceNode);
00495 
00496     virtual void
00497     outputToResultTree(
00498             const XObject&      xobj,
00499             const LocatorType*  locator);
00500 
00501     virtual void
00502     outputResultTreeFragment(
00503             const XObject&      theTree,
00504             const LocatorType*  locator);
00505 
00506     virtual const XalanDOMString&
00507     getXSLNameSpaceURL() const;
00508 
00509     virtual const XalanDOMString&
00510     getXalanXSLNameSpaceURL() const;
00511 
00512     virtual bool
00513     findOnElementRecursionStack(const ElemTemplateElement*  theElement) const;
00514 
00515     virtual void
00516     pushOnElementRecursionStack(const ElemTemplateElement*  theElement);
00517 
00518     virtual const ElemTemplateElement*
00519     popElementRecursionStack();
00520 
00521     virtual bool
00522     returnXResultTreeFrag(XResultTreeFrag*  theXResultTreeFrag);
00523 
00524     virtual eEscapeURLs
00525     getEscapeURLs() const;
00526 
00527     virtual void
00528     setEscapeURLs(eEscapeURLs   value);
00529 
00530     virtual eOmitMETATag
00531     getOmitMETATag() const;
00532 
00533     void
00534     setOmitMETATag(eOmitMETATag     value);
00535 
00536     virtual FormatterListener*
00537     createFormatterToXML(
00538             Writer&                 writer,
00539             const XalanDOMString&   version = XalanDOMString(),
00540             bool                    doIndent = false,
00541             int                     indent = eDefaultXMLIndentAmount,
00542             const XalanDOMString&   encoding = XalanDOMString(),
00543             const XalanDOMString&   mediaType = XalanDOMString(),
00544             const XalanDOMString&   doctypeSystem = XalanDOMString(),
00545             const XalanDOMString&   doctypePublic = XalanDOMString(),
00546             bool                    xmlDecl = true,
00547             const XalanDOMString&   standalone = XalanDOMString());
00548 
00549     virtual FormatterListener*
00550     createFormatterToHTML(
00551             Writer&                 writer,
00552             const XalanDOMString&   encoding = XalanDOMString(),
00553             const XalanDOMString&   mediaType = XalanDOMString(),
00554             const XalanDOMString&   doctypeSystem = XalanDOMString(),
00555             const XalanDOMString&   doctypePublic = XalanDOMString(),
00556             bool                    doIndent = true,
00557             int                     indent = eDefaultHTMLIndentAmount,
00558             bool                    escapeURLs = true,
00559             bool                    omitMetaTag = false);
00560 
00561     virtual FormatterListener*
00562     createFormatterToText(
00563             Writer&                 writer,
00564             const XalanDOMString&   encoding);
00565 
00566     virtual NodeSorter*
00567     borrowNodeSorter();
00568 
00569     virtual bool
00570     returnNodeSorter(NodeSorter*    theSorter);
00571 
00572     virtual XalanNumberFormatAutoPtr
00573     createXalanNumberFormat();
00574 
00575     // A basic class to create XalanNumberFormat instances...
00576     class XALAN_XSLT_EXPORT XalanNumberFormatFactory
00577     {
00578     public:
00579 
00580         explicit
00581         XalanNumberFormatFactory();
00582 
00583         virtual
00584         ~XalanNumberFormatFactory();
00585 
00586         virtual XalanNumberFormat*
00587         create();
00588     };
00589 
00590     static XalanNumberFormatFactory&
00591     getDefaultXalanNumberFormatFactory()
00592     {
00593         return s_defaultXalanNumberFormatFactory;
00594     }
00595 
00603     static XalanNumberFormatFactory*
00604     installXalanNumberFormatFactory(XalanNumberFormatFactory*   theFactory);
00605 
00606 
00607     virtual tl_size_type
00608     getTraceListeners() const;
00609 
00610     virtual void
00611     fireGenerateEvent(const GenerateEvent&  ge);
00612 
00613     virtual void
00614     fireTraceEvent(const TracerEvent&   te);
00615 
00616     virtual void
00617     fireSelectEvent(const SelectionEvent&   se);
00618 
00619     virtual bool
00620     getTraceSelects() const;
00621 
00622     virtual void
00623     traceSelect(
00624             const ElemTemplateElement&  theStylesheetElement,
00625             const NodeRefListBase&      nl,
00626             const XPath*                xpath);
00627 
00628     virtual int
00629     collationCompare(
00630             const XalanDOMString&               theLHS,
00631             const XalanDOMString&               theRHS,
00632             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault);
00633 
00634     virtual int
00635     collationCompare(
00636             const XalanDOMString&               theLHS,
00637             const XalanDOMString&               theRHS,
00638             const XalanDOMString&               theLocale,
00639             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault);
00640 
00641     virtual int
00642     collationCompare(
00643             const XalanDOMChar*                 theLHS,
00644             const XalanDOMChar*                 theRHS,
00645             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault);
00646 
00647     virtual int
00648     collationCompare(
00649             const XalanDOMChar*                 theLHS,
00650             const XalanDOMChar*                 theRHS,
00651             const XalanDOMChar*                 theLocale,
00652             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault);
00653 
00654     typedef XalanCollationServices::CollationCompareFunctor     CollationCompareFunctor;
00655 
00656     class XALAN_XSLT_EXPORT DefaultCollationCompareFunctor : public CollationCompareFunctor
00657     {
00658     public:
00659 
00660         DefaultCollationCompareFunctor();
00661 
00662         virtual
00663         ~DefaultCollationCompareFunctor();
00664 
00665         virtual int
00666         operator()(
00667             const XalanDOMChar*                 theLHS,
00668             const XalanDOMChar*                 theRHS,
00669             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) const;
00670 
00671         virtual int
00672         operator()(
00673             const XalanDOMChar*                 theLHS,
00674             const XalanDOMChar*                 theRHS,
00675             const XalanDOMChar*                 theLocale,
00676             XalanCollationServices::eCaseOrder  theCaseOrder = XalanCollationServices::eDefault) const;
00677     };
00678 
00679     const CollationCompareFunctor*
00680     installCollationCompareFunctor(CollationCompareFunctor*     theFunctor);
00681 
00682     CollationCompareFunctor*
00683     uninstallCollationCompareFunctor();
00684 
00685 
00686     class XALAN_XSLT_EXPORT FormatNumberFunctor
00687     {
00688     public:
00689 
00690         FormatNumberFunctor() {};
00691 
00692         virtual
00693         ~FormatNumberFunctor() {};
00694 
00695         virtual void
00696         operator() (
00697             XPathExecutionContext&              executionContext,
00698             double                              theNumber,
00699             const XalanDOMString&               thePattern,
00700             const XalanDecimalFormatSymbols*    theDFS,
00701             XalanDOMString&                     theResult,
00702             const XalanNode*                    context = 0,
00703             const LocatorType*                  locator = 0) const = 0;
00704     };
00705 
00706     virtual void
00707     formatNumber(
00708             double                  number,
00709             const XalanDOMString&   pattern,
00710             XalanDOMString&         theResult,
00711             const XalanNode*        context = 0,
00712             const LocatorType*      locator = 0);
00713 
00714     virtual void
00715     formatNumber(
00716             double                  number,
00717             const XalanDOMString&   pattern,
00718             const XalanDOMString&   dfsName,
00719             XalanDOMString&         theResult,
00720             const XalanNode*        context = 0,
00721             const LocatorType*      locator = 0);
00722 
00723 
00724     const FormatNumberFunctor* 
00725     installFormatNumberFunctor(FormatNumberFunctor*     formatNumberFunctor);
00726     
00727     FormatNumberFunctor*
00728     uninstallFormatNumberFunctor();
00729 
00730     virtual bool
00731     getInConstruction(const KeyDeclaration&     keyDeclaration) const;
00732 
00733     virtual void
00734     beginConstruction(const KeyDeclaration&     keyDeclaration);
00735 
00736     virtual void
00737     endConstruction(const KeyDeclaration&   keyDeclaration);
00738 
00739     virtual PrintWriter*
00740     createPrintWriter(XalanOutputStream*        theTextOutputStream);
00741 
00742     virtual PrintWriter*
00743     createPrintWriter(
00744             const XalanDOMString&       theFileName,
00745             const XalanDOMString&       theEncoding);
00746 
00747     virtual PrintWriter*
00748     createPrintWriter(StreamType&   theStream);
00749 
00750     virtual PrintWriter*
00751     createPrintWriter(FILE*     theStream);
00752 
00753     virtual CountersTable&
00754     getCountersTable();
00755 
00756     virtual void
00757     characters(const XalanNode&     node);
00758 
00759     virtual void
00760     characters(const XObjectPtr&    xobject);
00761 
00762     virtual void
00763     charactersRaw(const XalanNode&  node);
00764 
00765     virtual void
00766     charactersRaw(const XObjectPtr&     xobject);
00767 
00768 
00769     // These interfaces are inherited from XPathExecutionContext...
00770 
00771     virtual void
00772     reset();
00773 
00774     virtual XalanNode*
00775     getCurrentNode() const;
00776 
00777     virtual void
00778     pushCurrentNode(XalanNode*  theCurrentNode);
00779 
00780     virtual void
00781     popCurrentNode();
00782 
00783     virtual bool
00784     isNodeAfter(
00785             const XalanNode&    node1,
00786             const XalanNode&    node2) const;
00787 
00788     virtual void
00789     pushContextNodeList(const NodeRefListBase&  theList);
00790 
00791     virtual void    
00792     popContextNodeList();
00793 
00794     virtual const NodeRefListBase&
00795     getContextNodeList() const;
00796 
00797     virtual size_type
00798     getContextNodeListLength() const;
00799 
00800     virtual size_type
00801     getContextNodeListPosition(const XalanNode&     contextNode) const;
00802 
00803     virtual bool
00804     elementAvailable(const XalanQName&  theQName) const;
00805 
00806     virtual bool
00807     elementAvailable(
00808             const XalanDOMString&   theName,
00809             const LocatorType*      locator) const;
00810 
00811     virtual bool
00812     functionAvailable(const XalanQName&     theQName) const;
00813 
00814     virtual bool
00815     functionAvailable(
00816             const XalanDOMString&   theName,
00817             const LocatorType*      locator) const;
00818 
00819     virtual const XObjectPtr
00820     extFunction(
00821             const XalanDOMString&           theNamespace,
00822             const XalanDOMString&           functionName,
00823             XalanNode*                      context,
00824             const XObjectArgVectorType&     argVec,
00825             const LocatorType*              locator);
00826 
00827     virtual XalanDocument*
00828     parseXML(
00829             const XalanDOMString&   urlString,
00830             const XalanDOMString&   base) const;
00831 
00832     virtual MutableNodeRefList*
00833     borrowMutableNodeRefList();
00834 
00835     virtual bool
00836     returnMutableNodeRefList(MutableNodeRefList*    theList);
00837 
00838     virtual MutableNodeRefList*
00839     createMutableNodeRefList() const;
00840 
00841     virtual XalanDOMString&
00842     getCachedString();
00843 
00844     virtual bool
00845     releaseCachedString(XalanDOMString&     theString);
00846 
00847     virtual void
00848     getNodeSetByKey(
00849             XalanDocument*          doc,
00850             const XalanQName&       qname,
00851             const XalanDOMString&   ref,
00852             MutableNodeRefList&     nodelist);
00853 
00854     virtual void
00855     getNodeSetByKey(            
00856             XalanDocument*          doc,
00857             const XalanDOMString&   name,
00858             const XalanDOMString&   ref,
00859             const LocatorType*      locator,
00860             MutableNodeRefList&     nodelist);
00861 
00862     virtual const XObjectPtr
00863     getVariable(
00864             const XalanQName&   name,
00865             const LocatorType*  locator = 0);
00866 
00867     virtual const PrefixResolver*
00868     getPrefixResolver() const;
00869 
00870     virtual void
00871     setPrefixResolver(const PrefixResolver*     thePrefixResolver);
00872 
00873     virtual const XalanDOMString*
00874     getNamespaceForPrefix(const XalanDOMString&     prefix) const;
00875 
00876     virtual XalanDOMString
00877     findURIFromDoc(const XalanDocument*     owner) const;
00878 
00879     virtual const XalanDOMString&
00880     getUnparsedEntityURI(
00881             const XalanDOMString&   theName,
00882             const XalanDocument&    theDocument) const;
00883 
00884     virtual bool
00885     shouldStripSourceNode(const XalanText&  node);
00886 
00887     virtual XalanDocument*
00888     getSourceDocument(const XalanDOMString&     theURI) const;
00889 
00890     virtual void
00891     setSourceDocument(
00892             const XalanDOMString&   theURI,
00893             XalanDocument*          theDocument);
00894 
00895 
00896     // These interfaces are inherited from ExecutionContext...
00897 
00898     virtual void
00899     error(
00900             const XalanDOMString&   msg,
00901             const XalanNode*        sourceNode,
00902             const LocatorType*      locator) const;
00903 
00904     virtual void
00905     error(
00906             const char*         msg,
00907             const XalanNode*    sourceNode,
00908             const LocatorType*  locator) const;
00909 
00910     virtual void
00911     warn(
00912             const XalanDOMString&   msg,
00913             const XalanNode*        sourceNode,
00914             const LocatorType*      locator) const;
00915 
00916     virtual void
00917     warn(
00918             const char*         msg,
00919             const XalanNode*    sourceNode,
00920             const LocatorType*  locator) const;
00921 
00922     virtual void
00923     message(
00924             const XalanDOMString&   msg,
00925             const XalanNode*    sourceNode,
00926             const LocatorType*  locator) const;
00927 
00928     virtual void
00929     message(
00930             const char*         msg,
00931             const XalanNode*    sourceNode,
00932             const LocatorType*  locator) const;
00933 
00934 
00935     class XPathCacheReturnFunctor
00936     {
00937     public:
00938 
00939         XPathCacheReturnFunctor(XSLTEngineImpl&     xsltProcessor) :
00940             m_xsltProcessor(xsltProcessor)
00941         {
00942         }
00943 
00944         void
00945         operator()(const XPathCacheMapType::value_type&     theCacheEntry);
00946 
00947     private:
00948 
00949         XSLTEngineImpl&     m_xsltProcessor;
00950     };
00951 
00956     XalanSourceTreeDocument*
00957     getSourceTreeFactory() const;
00958 
00959 protected:
00960 
00961     virtual FormatterToText*
00962     borrowFormatterToText();
00963 
00964     virtual bool
00965     returnFormatterToText(FormatterToText*  theFormatter);
00966 
00967 private:
00968 
00969     const XalanDecimalFormatSymbols*
00970     getDecimalFormatSymbols(const XalanQName&   qname);
00971 
00979     void
00980     getParams(
00981             const ElemTemplateElement&  xslCallTemplateElement,
00982             ParamsVectorType&           params);
00983 
00990     bool
00991     isCached(const XPath*   theXPath);
00992 
00996     void
00997     clearXPathCache();
00998 
01006     void
01007     addToXPathCache(
01008             const XalanDOMString&   pattern,
01009             const XPath*            theXPath);
01010 
01011 
01015     void
01016     cleanUpTransients();
01017 
01018     XPathExecutionContextDefault    m_xpathExecutionContextDefault;
01019 
01020     XSLTEngineImpl*                 m_xsltProcessor;
01021 
01022     XalanNode*                      m_rootDocument;
01023 
01024     enum { eXPathCacheMax = 50,
01025            eDefaultParamsVectorSize = 10,
01026            eXResultTreeFragAllocatorBlockSize = 10,
01027            eDocumentAllocatorBlockSize = 10,
01028            eDocumentFragmentAllocatorBlockSize = 10,
01029            eDefaultAttributeAllocatorBlockSize = 10,
01030            eDefaultAttributeNSAllocatorBlockSize = 10,
01031            eDefaultCommentAllocatorBlockSize = 10,
01032            eDefaultElementAllocatorBlockSize = 10,
01033            eDefaultElementNSAllocatorBlockSize = 10,
01034            eDefaultPIAllocatorBlockSize = 10,
01035            eDefaultTextAllocatorBlockSize = 20,
01036            eDefaultTextIWSAllocatorBlockSize = 20 };
01037 
01038     ElementTemplateElementStackType     m_elementRecursionStack;
01039 
01040     const StylesheetRoot*               m_stylesheetRoot;
01041 
01042     FormatterListenerVectorType         m_formatterListeners;
01043 
01044     PrintWriterVectorType               m_printWriters;
01045 
01046     OutputStreamVectorType              m_outputStreams;
01047 
01048     CollationCompareFunctor*            m_collationCompareFunctor;
01049 
01050     FormatNumberFunctor *               m_formatNumberFunctor;
01051 
01055     VariablesStack                      m_variablesStack;
01056 
01057     ParamsVectorType                    m_paramsVector;
01058 
01059     XPathCacheMapType                   m_matchPatternCache;
01060 
01061     KeyTablesTableType                  m_keyTables;
01062 
01063     KeyDeclarationSetType               m_keyDeclarationSet;
01064 
01065     CountersTable                       m_countersTable;
01066 
01071     mutable XalanAutoPtr<XalanSourceTreeDocument>   m_sourceTreeResultTreeFactory;
01072 
01073     // Holds the current mode.
01074     const XalanQName*                   m_mode;
01075 
01076     CurrentTemplateStackType            m_currentTemplateStack;
01077 
01078     typedef XalanObjectCacheDefault<FormatterToText>        FormatterToTextCacheType;
01079     typedef XalanObjectCacheDefault<FormatterToSourceTree>  FormatterToSourceTreeCacheType;
01080     typedef XalanObjectCacheDefault<NodeSorter>             NodeSorterCacheType;
01081 
01082     FormatterToTextCacheType            m_formatterToTextCache;
01083 
01084     FormatterToSourceTreeCacheType      m_formatterToSourceTreeCache;
01085 
01086     NodeSorterCacheType                 m_nodeSorterCache;
01087 
01088     int                                 m_indentAmount;
01089 
01090     XResultTreeFragAllocator            m_xresultTreeFragAllocator;
01091 
01092     XalanSourceTreeDocumentFragmentAllocator    m_documentFragmentAllocator;
01093 
01094     XalanSourceTreeDocumentAllocator    m_documentAllocator;
01095 
01096     // If true, we will use a separate document factory for
01097     // result tree fragments.
01098     bool                                m_usePerInstanceDocumentFactory;
01099 
01100     // If true, only text nodes will be cloned in the output...
01101     bool                                m_cloneTextNodesOnly;
01102 
01103     // Determines whether or not to override the property in the stylesheet.
01104     eEscapeURLs                         m_escapeURLs;
01105 
01106     // Determines whether or not to override the property in the stylesheet.
01107     eOmitMETATag                        m_omitMETATag;
01108 
01109     bool                                m_hasStripOrPreserveSpace;
01110 
01111     static XalanNumberFormatFactory     s_defaultXalanNumberFormatFactory;
01112 
01113     static XalanNumberFormatFactory*    s_xalanNumberFormatFactory;
01114 
01115     static const DefaultCollationCompareFunctor     s_defaultCollationFunctor;
01116 
01117 };
01118 
01119 
01120 
01121 XALAN_CPP_NAMESPACE_END
01122 
01123 
01124 
01125 #endif  // STYLESHEETEXECUTIONCONTEXTDEFAULT_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.8
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.