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(STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680) 00017 #define STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680 00018 00019 00020 00021 // Base include file. Must be first. 00022 #include <xalanc/XSLT/XSLTDefinitions.hpp> 00023 00024 00025 00026 #include <cstddef> 00027 #include <cstdio> 00028 #include <memory> 00029 00030 00031 00032 // Base class header file... 00033 #include <xalanc/XPath/XPathExecutionContext.hpp> 00034 00035 00036 00037 00038 #include <xalanc/XalanDOM/XalanDOMString.hpp> 00039 00040 00041 00042 // Base class header file... 00043 #include <xalanc/PlatformSupport/ExecutionContext.hpp> 00044 00045 00046 00047 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) 00048 #include <xalanc/PlatformSupport/XalanNumberFormat.hpp> 00049 #endif 00050 00051 00052 00053 #include <xalanc/Include/XalanMemMgrAutoPtr.hpp> 00054 00055 00056 00057 00058 #include <xalanc/PlatformSupport/AttributeListImpl.hpp> 00059 #include <xalanc/PlatformSupport/XalanCollationServices.hpp> 00060 00061 00062 00063 #include <xalanc/XSLT/TopLevelArg.hpp> 00064 00065 00066 00067 XALAN_CPP_NAMESPACE_BEGIN 00068 00069 00070 00071 class CountersTable; 00072 class ElemTemplate; 00073 class ElemTemplateElement; 00074 class ElemVariable; 00075 class FormatterListener; 00076 class FormatterToText; 00077 class GenerateEvent; 00078 class KeyDeclaration; 00079 class PrefixResolver; 00080 class NodeRefListBase; 00081 class NodeSorter; 00082 class PrintWriter; 00083 class XalanQName; 00084 class SelectionEvent; 00085 class Stylesheet; 00086 class StylesheetRoot; 00087 class XalanOutputStream; 00088 class TracerEvent; 00089 class Writer; 00090 class XalanDocument; 00091 class XalanDocumentFragment; 00092 class XalanElement; 00093 class XalanNode; 00094 class XalanNumberFormat; 00095 class XPath; 00096 class XObject; 00097 class XObjectPtr; 00098 class XResultTreeFrag; 00099 00100 00101 00102 // 00103 // An abstract class which provides support for executing stylesheets. 00104 // 00105 class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext 00106 { 00107 public: 00108 00109 #if defined(XALAN_STRICT_ANSI_HEADERS) 00110 typedef std::size_t tl_size_type; 00111 #else 00112 typedef size_t tl_size_type; 00113 #endif 00114 00115 #if defined(XALAN_NO_STD_NAMESPACE) 00116 typedef ostream StreamType; 00117 #else 00118 typedef std::ostream StreamType; 00119 #endif 00120 00121 explicit 00122 StylesheetExecutionContext(MemoryManagerType& m_memoryManager, XObjectFactory* theXObjectFactory = 0); 00123 00124 virtual 00125 ~StylesheetExecutionContext(); 00126 00127 // These interfaces are new... 00128 00136 virtual void 00137 error( 00138 const XalanDOMString& msg, 00139 const ElemTemplateElement& styleNode, 00140 const XalanNode* sourceNode = 0) const = 0; 00141 00149 virtual void 00150 warn( 00151 const XalanDOMString& msg, 00152 const ElemTemplateElement& styleNode, 00153 const XalanNode* sourceNode = 0) const = 0; 00154 00162 virtual void 00163 message( 00164 const XalanDOMString& msg, 00165 const ElemTemplateElement& styleNode, 00166 const XalanNode* sourceNode = 0) const = 0; 00167 00168 00174 virtual bool 00175 getQuietConflictWarnings() const = 0; 00176 00183 virtual bool 00184 getCopyTextNodesOnly() const = 0; 00185 00192 virtual void 00193 pushCopyTextNodesOnly(bool copyTextNodesOnly) = 0; 00194 00199 virtual bool 00200 popCopyTextNodesOnly() = 0; 00201 00202 /* 00203 * A class to manage setting and restoring the flag 00204 * for restricting copying only text nodes to the 00205 * result tree 00206 */ 00207 class SetAndRestoreCopyTextNodesOnly 00208 { 00209 public: 00210 00211 SetAndRestoreCopyTextNodesOnly( 00212 StylesheetExecutionContext& executionContext, 00213 bool fValue) : 00214 m_executionContext(executionContext) 00215 { 00216 executionContext.pushCopyTextNodesOnly(fValue); 00217 } 00218 00219 ~SetAndRestoreCopyTextNodesOnly() 00220 { 00221 m_executionContext.popCopyTextNodesOnly(); 00222 } 00223 00224 private: 00225 00226 // Not implemented... 00227 SetAndRestoreCopyTextNodesOnly(const SetAndRestoreCopyTextNodesOnly&); 00228 00229 SetAndRestoreCopyTextNodesOnly& 00230 operator=(const SetAndRestoreCopyTextNodesOnly&); 00231 00232 // Data members... 00233 StylesheetExecutionContext& m_executionContext; 00234 00235 }; 00236 00237 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00238 00242 virtual void 00243 pushProcessCurrentAttribute(bool processAttribute) = 0; 00244 00248 virtual bool 00249 popProcessCurrentAttribute() = 0; 00250 00256 virtual void 00257 pushSkipElementAttributes(bool skipAttributes) = 0; 00258 00263 virtual bool 00264 getSkipElementAttributes() const = 0; 00265 00269 virtual bool 00270 popSkipElementAttributes() = 0; 00271 00277 virtual void 00278 pushExecuteIf(bool executeIf) = 0; 00279 00285 virtual bool 00286 popExecuteIf() = 0; 00287 #endif 00288 00296 virtual XalanNode* 00297 getRootDocument() const = 0; 00298 00306 virtual void 00307 setRootDocument(XalanNode* theDocument) = 0; 00308 00314 virtual void 00315 setStylesheetRoot(const StylesheetRoot* theStylesheet) = 0; 00316 00322 virtual const XalanQName* 00323 getCurrentMode() const = 0; 00324 00330 virtual void 00331 pushCurrentMode(const XalanQName* theMode) = 0; 00332 00333 00337 virtual void 00338 popCurrentMode() =0; 00339 00345 virtual const ElemTemplate* 00346 getCurrentTemplate() const = 0; 00347 00353 virtual void 00354 pushCurrentTemplate(const ElemTemplate* theTemplate) = 0; 00355 00356 virtual void 00357 popCurrentTemplate() = 0; 00358 00359 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00360 /* 00361 * A class to manage pushing and popping the current 00362 * template instance. 00363 */ 00364 class PushAndPopCurrentTemplate 00365 { 00366 public: 00367 00368 PushAndPopCurrentTemplate( 00369 StylesheetExecutionContext& executionContext, 00370 const ElemTemplate* theTemplate) : 00371 m_executionContext(executionContext) 00372 { 00373 executionContext.pushCurrentTemplate(theTemplate); 00374 } 00375 00376 ~PushAndPopCurrentTemplate() 00377 { 00378 m_executionContext.popCurrentTemplate(); 00379 } 00380 00381 private: 00382 00383 // Data members... 00384 StylesheetExecutionContext& m_executionContext; 00385 }; 00386 #endif 00387 00393 virtual bool 00394 doDiagnosticsOutput() const = 0; 00395 00401 virtual void 00402 diag(const XalanDOMString& theString) = 0; 00403 00410 virtual void 00411 pushTime(const void* theKey) = 0; 00412 00419 virtual void 00420 displayDuration( 00421 const XalanDOMString& theMessage, 00422 const void* theKey) = 0; 00423 00427 virtual bool 00428 isElementPending() const = 0; 00429 00437 virtual void 00438 replacePendingAttribute( 00439 const XalanDOMChar* theName, 00440 const XalanDOMChar* theNewType, 00441 const XalanDOMChar* theNewValue) = 0; 00442 00448 virtual FormatterListener* 00449 getFormatterListener() const = 0; 00450 00456 virtual void 00457 setFormatterListener(FormatterListener* flistener) = 0; 00458 00459 virtual void 00460 pushOutputContext(FormatterListener* flistener = 0) = 0; 00461 00462 virtual void 00463 popOutputContext() = 0; 00464 00465 class OutputContextPushPop 00466 { 00467 public: 00468 00475 OutputContextPushPop( 00476 StylesheetExecutionContext& theExecutionContext, 00477 FormatterListener* theNewListener = 0) : 00478 m_executionContext(theExecutionContext) 00479 { 00480 m_executionContext.pushOutputContext(theNewListener); 00481 } 00482 00483 ~OutputContextPushPop() 00484 { 00485 m_executionContext.popOutputContext(); 00486 } 00487 00488 private: 00489 00490 StylesheetExecutionContext& m_executionContext; 00491 }; 00492 00499 virtual void 00500 addResultAttribute( 00501 const XalanDOMString& aname, 00502 const XalanDOMString& value) = 0; 00503 00510 virtual void 00511 addResultAttribute( 00512 const XalanDOMString& aname, 00513 const XalanDOMChar* value) = 0; 00514 00520 virtual void 00521 copyNamespaceAttributes(const XalanNode& src) = 0; 00522 00530 virtual const XalanDOMString* 00531 getResultPrefixForNamespace(const XalanDOMString& theNamespace) const = 0; 00532 00540 virtual const XalanDOMString* 00541 getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const = 0; 00542 00551 virtual bool 00552 isPendingResultPrefix(const XalanDOMString& thePrefix) = 0; 00553 00554 00560 virtual void 00561 getUniqueNamespaceValue(XalanDOMString& theValue) const = 0; 00562 00568 virtual int 00569 getIndent() const = 0; 00570 00576 virtual void 00577 setIndent(int indentAmount) = 0; 00578 00587 virtual const XPath* 00588 createMatchPattern( 00589 const XalanDOMString& str, 00590 const PrefixResolver& resolver) = 0; 00591 00597 virtual void 00598 returnXPath(const XPath* xpath) = 0; 00599 00600 // A helper class to automatically return an XPath instance. 00601 class XPathGuard 00602 { 00603 public: 00604 00605 XPathGuard( 00606 StylesheetExecutionContext& context, 00607 const XPath* xpath = 0) : 00608 m_context(context), 00609 m_xpath(xpath) 00610 { 00611 } 00612 00613 ~XPathGuard() 00614 { 00615 if (m_xpath != 0) 00616 { 00617 m_context.returnXPath(m_xpath); 00618 } 00619 } 00620 00621 const XPath* 00622 get() const 00623 { 00624 return m_xpath; 00625 } 00626 00627 const XPath* 00628 release() 00629 { 00630 const XPath* const temp = m_xpath; 00631 00632 m_xpath = 0; 00633 00634 return temp; 00635 } 00636 00637 void 00638 reset(const XPath* xpath) 00639 { 00640 if (m_xpath != 0) 00641 { 00642 m_context.returnXPath(m_xpath); 00643 } 00644 00645 m_xpath = xpath; 00646 } 00647 00648 private: 00649 00650 StylesheetExecutionContext& m_context; 00651 00652 const XPath* m_xpath; 00653 }; 00654 00655 typedef XalanVector<TopLevelArg> ParamVectorType; 00656 00663 virtual void 00664 pushTopLevelVariables(const ParamVectorType& topLevelParams) = 0; 00665 00675 virtual const XObjectPtr 00676 createVariable( 00677 const XPath& xpath, 00678 XalanNode* contextNode, 00679 const PrefixResolver& resolver) = 0; 00680 00681 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00682 00690 virtual const XObjectPtr 00691 createVariable( 00692 const ElemTemplateElement& templateChild, 00693 XalanNode* sourceNode) = 0; 00694 #endif 00695 00708 virtual void 00709 pushVariable( 00710 const XalanQName& name, 00711 const ElemTemplateElement* element, 00712 const XalanDOMString& str, 00713 XalanNode* contextNode, 00714 const PrefixResolver& resolver) = 0; 00715 00727 virtual void 00728 pushVariable( 00729 const XalanQName& name, 00730 const ElemTemplateElement* element, 00731 const XPath& xpath, 00732 XalanNode* contextNode, 00733 const PrefixResolver& resolver) = 0; 00734 00735 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00736 00745 virtual void 00746 pushVariable( 00747 const XalanQName& name, 00748 const ElemTemplateElement* element, 00749 const ElemTemplateElement& templateChild, 00750 XalanNode* sourceNode) = 0; 00751 #endif 00752 00761 virtual void 00762 pushVariable( 00763 const XalanQName& name, 00764 const XObjectPtr val, 00765 const ElemTemplateElement* element) = 0; 00766 00775 virtual void 00776 pushVariable( 00777 const XalanQName& name, 00778 const ElemVariable* var, 00779 const ElemTemplateElement* element) = 0; 00780 00785 virtual void 00786 pushContextMarker() = 0; 00787 00791 virtual void 00792 popContextMarker() = 0; 00793 00794 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00795 /* 00796 * A class to manage pushing and popping an element's stack 00797 * frame context. 00798 */ 00799 class PushAndPopContextMarker 00800 { 00801 public: 00802 00803 PushAndPopContextMarker(StylesheetExecutionContext& executionContext) : 00804 m_executionContext(executionContext) 00805 { 00806 executionContext.pushContextMarker(); 00807 } 00808 00809 PushAndPopContextMarker( 00810 StylesheetExecutionContext& executionContext, 00811 int& currentStackFrameIndex) : 00812 m_executionContext(executionContext) 00813 { 00814 currentStackFrameIndex = executionContext.getCurrentStackFrameIndex(); 00815 00816 executionContext.pushContextMarker(); 00817 } 00818 00819 ~PushAndPopContextMarker() 00820 { 00821 m_executionContext.popContextMarker(); 00822 } 00823 00824 StylesheetExecutionContext& 00825 getExecutionContext() const 00826 { 00827 return m_executionContext; 00828 } 00829 00830 private: 00831 00832 StylesheetExecutionContext& m_executionContext; 00833 }; 00834 #endif 00835 00839 virtual void 00840 resolveTopLevelParams() = 0; 00841 00845 virtual void 00846 clearTopLevelParams() = 0; 00847 00848 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00849 class ResolveAndClearTopLevelParams 00850 { 00851 public: 00852 00853 ResolveAndClearTopLevelParams(StylesheetExecutionContext& executionContext) : 00854 m_executionContext(executionContext) 00855 { 00856 m_executionContext.resolveTopLevelParams(); 00857 } 00858 00859 ~ResolveAndClearTopLevelParams() 00860 { 00861 m_executionContext.clearTopLevelParams(); 00862 } 00863 00864 private: 00865 00866 StylesheetExecutionContext& m_executionContext; 00867 }; 00868 00875 virtual void 00876 pushParams(const ElemTemplateElement& xslCallTemplateElement) = 0; 00877 00878 #else 00879 00883 virtual void beginParams() = 0; 00884 00888 virtual void endParams() = 0; 00889 00895 virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue) = 0; 00896 #endif 00897 00908 virtual const XObjectPtr 00909 getParamVariable(const XalanQName& theName) = 0; 00910 00916 virtual void 00917 pushElementFrame(const ElemTemplateElement* elem) = 0; 00918 00924 virtual void 00925 popElementFrame() = 0; 00926 00927 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 00928 /* 00929 * A class to manage pushing and popping an element's stack 00930 * frame context. 00931 */ 00932 class PushAndPopElementFrame 00933 { 00934 public: 00935 00936 PushAndPopElementFrame( 00937 StylesheetExecutionContext& executionContext, 00938 const ElemTemplateElement* element) : 00939 m_executionContext(executionContext) 00940 { 00941 executionContext.pushElementFrame(element); 00942 } 00943 00944 ~PushAndPopElementFrame() 00945 { 00946 m_executionContext.popElementFrame(); 00947 } 00948 00949 private: 00950 00951 StylesheetExecutionContext& m_executionContext; 00952 }; 00953 #endif 00954 00960 virtual int 00961 getGlobalStackFrameIndex() const = 0; 00962 00969 virtual int 00970 getCurrentStackFrameIndex() const = 0; 00971 00978 virtual void 00979 pushCurrentStackFrameIndex(int currentStackFrameIndex = -1) = 0; 00980 00984 virtual void 00985 popCurrentStackFrameIndex() = 0; 00986 00987 /* 00988 * A class to manage the state of the variable stacks frame index. 00989 */ 00990 class SetAndRestoreCurrentStackFrameIndex 00991 { 00992 public: 00993 00994 SetAndRestoreCurrentStackFrameIndex( 00995 StylesheetExecutionContext& executionContext, 00996 int newIndex) : 00997 m_executionContext(executionContext), 00998 m_savedIndex(executionContext.getCurrentStackFrameIndex()) 00999 { 01000 executionContext.pushCurrentStackFrameIndex(newIndex); 01001 } 01002 01003 ~SetAndRestoreCurrentStackFrameIndex() 01004 { 01005 m_executionContext.popCurrentStackFrameIndex(); 01006 } 01007 01008 private: 01009 01010 StylesheetExecutionContext& m_executionContext; 01011 01012 const int m_savedIndex; 01013 }; 01014 01015 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01016 /* 01017 * A class to manage stack state during execution. 01018 */ 01019 class ParamsPushPop : public PushAndPopContextMarker 01020 { 01021 public: 01022 01023 ParamsPushPop( 01024 StylesheetExecutionContext& executionContext, 01025 const ElemTemplateElement& xslCallTemplateElement) : 01026 PushAndPopContextMarker(executionContext) 01027 { 01028 doPush(xslCallTemplateElement); 01029 } 01030 01031 ParamsPushPop( 01032 StylesheetExecutionContext& executionContext, 01033 const ElemTemplateElement& xslCallTemplateElement, 01034 int& savedStackFrameIndex) : 01035 PushAndPopContextMarker(executionContext, savedStackFrameIndex) 01036 { 01037 doPush( 01038 xslCallTemplateElement, 01039 savedStackFrameIndex); 01040 } 01041 01042 ~ParamsPushPop() 01043 { 01044 } 01045 01046 private: 01047 01048 void 01049 doPush( 01050 const ElemTemplateElement& xslCallTemplateElement, 01051 int stackFrameIndex); 01052 01053 void 01054 doPush(const ElemTemplateElement& xslCallTemplateElement); 01055 }; 01056 #endif 01057 01067 virtual void 01068 startDocument() = 0; 01069 01081 virtual void 01082 endDocument() = 0; 01083 01089 virtual void 01090 startElement(const XalanDOMChar* name) = 0; 01091 01097 virtual void 01098 endElement(const XalanDOMChar* name) = 0; 01099 01107 virtual void 01108 characters( 01109 const XalanDOMChar* ch, 01110 XalanDOMString::size_type start, 01111 XalanDOMString::size_type length) = 0; 01112 01122 virtual void 01123 charactersRaw( 01124 const XalanDOMChar* ch, 01125 XalanDOMString::size_type start, 01126 XalanDOMString::size_type length) = 0; 01127 01133 virtual void 01134 comment(const XalanDOMChar* data) = 0; 01135 01142 virtual void 01143 processingInstruction( 01144 const XalanDOMChar* target, 01145 const XalanDOMChar* data) = 0; 01146 01150 virtual void 01151 flushPending() = 0; 01152 01159 virtual void 01160 cloneToResultTree( 01161 const XalanNode& node, 01162 const LocatorType* locator) = 0; 01163 01173 virtual void 01174 cloneToResultTree( 01175 const XalanNode& node, 01176 XalanNode::NodeType nodeType, 01177 bool overrideStrip, 01178 bool shouldCloneAttributes, 01179 const LocatorType* locator) = 0; 01180 01181 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01182 01186 virtual void 01187 beginCreateXResultTreeFrag( 01188 XalanNode* sourceNode) = 0; 01189 01194 virtual const XObjectPtr 01195 endCreateXResultTreeFrag() = 0; 01196 01202 virtual void 01203 beginFormatToText( 01204 XalanDOMString& theResult) = 0; 01205 01210 virtual void 01211 endFormatToText() = 0; 01212 #else 01213 01220 virtual const XObjectPtr 01221 createXResultTreeFrag( 01222 const ElemTemplateElement& templateChild, 01223 XalanNode* sourceNode) = 0; 01224 #endif 01225 01233 virtual void 01234 outputToResultTree( 01235 const XObject& xobj, 01236 const LocatorType* locator) = 0; 01237 01245 virtual void 01246 outputResultTreeFragment( 01247 const XObject& theTree, 01248 const LocatorType* locator) = 0; 01249 01255 virtual const XalanDOMString& 01256 getXSLNameSpaceURL() const = 0; 01257 01263 virtual const XalanDOMString& 01264 getXalanXSLNameSpaceURL() const = 0; 01265 01271 virtual bool 01272 findOnElementRecursionStack(const ElemTemplateElement* theElement) const = 0; 01273 01279 virtual void 01280 pushOnElementRecursionStack(const ElemTemplateElement* theElement) = 0; 01281 01287 virtual const ElemTemplateElement* 01288 popElementRecursionStack() = 0; 01289 01293 class ElementRecursionStackPusher 01294 { 01295 public: 01296 01303 ElementRecursionStackPusher( 01304 StylesheetExecutionContext& executionContext, 01305 const ElemTemplateElement* element) : 01306 m_executionContext(executionContext) 01307 { 01308 m_executionContext.pushOnElementRecursionStack(element); 01309 } 01310 01311 ~ElementRecursionStackPusher() 01312 { 01313 m_executionContext.popElementRecursionStack(); 01314 } 01315 01316 private: 01317 01318 StylesheetExecutionContext& m_executionContext; 01319 }; 01320 01321 01331 virtual bool 01332 returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag) = 0; 01333 01334 01335 enum eDummy 01336 { 01337 eDefaultXMLIndentAmount = 0, 01338 eDefaultHTMLIndentAmount = 0 01339 }; 01340 01344 enum eEscapeURLs 01345 { 01346 eEscapeURLsDefault, // Use the value in the stylesheet 01347 eEscapeURLsNo, // Don't escape URLs 01348 eEscapeURLsYes // Escape URLs 01349 }; 01350 01358 virtual eEscapeURLs 01359 getEscapeURLs() const = 0; 01360 01368 virtual void 01369 setEscapeURLs(eEscapeURLs value) = 0; 01370 01371 01375 enum eOmitMETATag 01376 { 01377 eOmitMETATagDefault, // Use the value in the stylesheet 01378 eOmitMETATagNo, // Don't omit the META tag 01379 eOmitMETATagYes // Omit the META tag 01380 }; 01381 01389 virtual eOmitMETATag 01390 getOmitMETATag() const = 0; 01391 01399 virtual void 01400 setOmitMETATag(eOmitMETATag value) = 0; 01401 01423 virtual FormatterListener* 01424 createFormatterToXML( 01425 Writer& writer, 01426 const XalanDOMString& version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01427 bool doIndent = false, 01428 int indent = eDefaultXMLIndentAmount, 01429 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01430 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01431 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01432 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01433 bool xmlDecl = true, 01434 const XalanDOMString& standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr())) = 0; 01435 01453 virtual FormatterListener* 01454 createFormatterToHTML( 01455 Writer& writer, 01456 const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01457 const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01458 const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01459 const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), 01460 bool doIndent = true, 01461 int indent = eDefaultHTMLIndentAmount, 01462 bool escapeURLs = true, 01463 bool omitMetaTag = false) = 0; 01464 01471 virtual FormatterListener* 01472 createFormatterToText( 01473 Writer& writer, 01474 const XalanDOMString& encoding) = 0; 01475 01476 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01477 class BorrowReturnFormatterToText 01478 { 01479 public: 01480 01481 BorrowReturnFormatterToText( 01482 StylesheetExecutionContext& executionContext, 01483 Writer& writer, 01484 bool normalizeLinefeed = true, 01485 bool handleIgnorableWhitespace = true); 01486 01487 ~BorrowReturnFormatterToText() 01488 { 01489 assert(m_formatter != 0); 01490 01491 m_executionContext.returnFormatterToText(m_formatter); 01492 } 01493 01494 FormatterToText& 01495 operator*() const 01496 { 01497 assert(m_formatter != 0); 01498 01499 return *m_formatter; 01500 } 01501 01502 FormatterToText* 01503 get() const 01504 { 01505 assert(m_formatter != 0); 01506 01507 return m_formatter; 01508 } 01509 01510 FormatterToText* 01511 operator->() const 01512 { 01513 return get(); 01514 } 01515 01516 private: 01517 01518 StylesheetExecutionContext& m_executionContext; 01519 01520 FormatterToText* m_formatter; 01521 }; 01522 01523 01524 friend class BorrowReturnFormatterToText; 01525 #endif 01526 01527 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01528 01531 virtual NodeSorter* 01532 getNodeSorter() = 0; 01533 01534 #else 01535 01540 virtual NodeSorter* 01541 borrowNodeSorter() = 0; 01542 01549 virtual bool 01550 returnNodeSorter(NodeSorter* theSorter) = 0; 01551 01552 class BorrowReturnNodeSorter 01553 { 01554 public: 01555 01556 BorrowReturnNodeSorter(StylesheetExecutionContext& executionContext) : 01557 m_executionContext(executionContext), 01558 m_sorter(executionContext.borrowNodeSorter()) 01559 { 01560 assert(m_sorter != 0); 01561 } 01562 01563 ~BorrowReturnNodeSorter() 01564 { 01565 assert(m_sorter != 0); 01566 01567 m_executionContext.returnNodeSorter(m_sorter); 01568 } 01569 01570 NodeSorter& 01571 operator*() const 01572 { 01573 assert(m_sorter != 0); 01574 01575 return *m_sorter; 01576 } 01577 01578 NodeSorter* 01579 get() const 01580 { 01581 assert(m_sorter != 0); 01582 01583 return m_sorter; 01584 } 01585 01586 NodeSorter* 01587 operator->() const 01588 { 01589 return get(); 01590 } 01591 01592 private: 01593 01594 StylesheetExecutionContext& m_executionContext; 01595 01596 NodeSorter* m_sorter; 01597 }; 01598 #endif 01599 01600 typedef XalanMemMgrAutoPtr<XalanNumberFormat,true> XalanNumberFormatAutoPtr; 01601 01608 virtual XalanNumberFormatAutoPtr 01609 createXalanNumberFormat() = 0; 01610 01611 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01612 /* 01613 * A class to manage the attribute sets that have been executed 01614 * by an element 01615 */ 01616 struct UseAttributeSetIndexes 01617 { 01618 UseAttributeSetIndexes() : 01619 attributeSetNameIndex(0), 01620 matchingAttributeSetIndex(0) {} 01621 01622 size_type attributeSetNameIndex; 01623 size_type matchingAttributeSetIndex; 01624 01625 01626 }; 01627 01628 virtual void 01629 createUseAttributeSetIndexesOnStack() = 0; 01630 01631 virtual UseAttributeSetIndexes& 01632 getUseAttributeSetIndexes() = 0; 01633 01634 virtual void 01635 popUseAttributeSetIndexesFromStack() = 0; 01636 01643 virtual void 01644 pushInvoker(const ElemTemplateElement * invoker) = 0; 01645 01649 virtual void 01650 popInvoker() = 0; 01651 01656 virtual const ElemTemplateElement* 01657 getInvoker() const = 0; 01658 #endif 01659 01665 virtual tl_size_type 01666 getTraceListeners() const = 0; 01667 01673 virtual void 01674 fireGenerateEvent(const GenerateEvent& ge) = 0; 01675 01681 virtual void 01682 fireTraceEvent(const TracerEvent& te) = 0; 01683 01689 virtual void 01690 fireSelectEvent(const SelectionEvent& se) = 0; 01691 01697 virtual bool 01698 getTraceSelects() const = 0; 01699 01707 virtual void 01708 traceSelect( 01709 const ElemTemplateElement& theStylesheetElement, 01710 const NodeRefListBase& nl, 01711 const XPath* xpath) = 0; 01712 01722 virtual int 01723 collationCompare( 01724 const XalanDOMString& theLHS, 01725 const XalanDOMString& theRHS, 01726 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; 01727 01738 virtual int 01739 collationCompare( 01740 const XalanDOMString& theLHS, 01741 const XalanDOMString& theRHS, 01742 const XalanDOMString& theLocale, 01743 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; 01744 01754 virtual int 01755 collationCompare( 01756 const XalanDOMChar* theLHS, 01757 const XalanDOMChar* theRHS, 01758 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; 01759 01770 virtual int 01771 collationCompare( 01772 const XalanDOMChar* theLHS, 01773 const XalanDOMChar* theRHS, 01774 const XalanDOMChar* theLocale, 01775 XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; 01776 01783 virtual bool 01784 getInConstruction(const KeyDeclaration& keyDeclaration) const = 0; 01785 01791 virtual void 01792 beginConstruction(const KeyDeclaration& keyDeclaration) = 0; 01793 01799 virtual void 01800 endConstruction(const KeyDeclaration& keyDeclaration) = 0; 01801 01808 virtual PrintWriter* 01809 createPrintWriter(XalanOutputStream* theTextOutputStream) = 0; 01810 01819 virtual PrintWriter* 01820 createPrintWriter( 01821 const XalanDOMString& theFileName, 01822 const XalanDOMString& theEncoding) = 0; 01823 01830 virtual PrintWriter* 01831 createPrintWriter(StreamType& theStream) = 0; 01832 01839 virtual PrintWriter* 01840 createPrintWriter(FILE* theStream) = 0; 01841 01848 virtual CountersTable& 01849 getCountersTable() = 0; 01850 01856 virtual void 01857 characters(const XalanNode& node) = 0; 01858 01864 virtual void 01865 characters(const XObjectPtr& xobject) = 0; 01866 01873 virtual void 01874 charactersRaw(const XalanNode& node) = 0; 01875 01881 virtual void 01882 charactersRaw(const XObjectPtr& xobject) = 0; 01883 01884 01885 // These interfaces are inherited from XPathExecutionContext... 01886 01887 virtual void 01888 reset() = 0; 01889 01890 virtual XalanNode* 01891 getCurrentNode() const = 0; 01892 01893 virtual void 01894 pushCurrentNode(XalanNode* theCurrentNode) = 0; 01895 01896 virtual void 01897 popCurrentNode() = 0; 01898 01899 virtual bool 01900 isNodeAfter( 01901 const XalanNode& node1, 01902 const XalanNode& node2) const = 0; 01903 01904 virtual void 01905 pushContextNodeList(const NodeRefListBase& theList) = 0; 01906 01907 virtual void 01908 popContextNodeList() = 0; 01909 01910 virtual const NodeRefListBase& 01911 getContextNodeList() const = 0; 01912 01913 virtual size_type 01914 getContextNodeListLength() const = 0; 01915 01916 virtual size_type 01917 getContextNodeListPosition(const XalanNode& contextNode) const = 0; 01918 01926 virtual bool 01927 elementAvailable(const XalanQName& theQName) const = 0; 01928 01938 virtual bool 01939 elementAvailable( 01940 const XalanDOMString& theName, 01941 const LocatorType* locator) const = 0; 01942 01950 virtual bool 01951 functionAvailable(const XalanQName& theQName) const = 0; 01952 01961 virtual bool 01962 functionAvailable( 01963 const XalanDOMString& theName, 01964 const LocatorType* locator) const = 0; 01965 01966 virtual const XObjectPtr 01967 extFunction( 01968 const XalanDOMString& theNamespace, 01969 const XalanDOMString& functionName, 01970 XalanNode* context, 01971 const XObjectArgVectorType& argVec, 01972 const LocatorType* locator) = 0; 01973 01974 virtual XalanDocument* 01975 parseXML( 01976 MemoryManagerType& theManager, 01977 const XalanDOMString& urlString, 01978 const XalanDOMString& base) const = 0; 01979 01980 virtual MutableNodeRefList* 01981 borrowMutableNodeRefList() = 0; 01982 01983 virtual bool 01984 returnMutableNodeRefList(MutableNodeRefList* theList) = 0; 01985 01986 virtual MutableNodeRefList* 01987 createMutableNodeRefList(MemoryManagerType& theManager) const = 0; 01988 01989 #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 01990 01991 virtual MutableNodeRefList& 01992 createAndPushMutableNodeRefList() = 0; 01993 01994 virtual void 01995 releaseAndPopMutableNodeRefList() = 0; 01996 01997 virtual void 01998 pushXObjectPtr(const XObjectPtr& xobjectPtr) = 0; 01999 02000 virtual void 02001 popXObjectPtr() = 0; 02002 02003 virtual void 02004 createAndPushNodesToTransformList(const NodeRefListBase* nodeList) = 0; 02005 02006 virtual XalanNode* 02007 getNextNodeToTransform() = 0; 02008 02009 virtual void 02010 popNodesToTransformList() = 0; 02011 02016 virtual XalanDOMString& 02017 getAndPushCachedString() = 0; 02018 02023 virtual XalanDOMString& 02024 getLastCachedString() = 0; 02025 02033 virtual XalanDOMString& 02034 getAndPopCachedString() = 0; 02035 #endif 02036 02037 virtual XalanDOMString& 02038 getCachedString() = 0; 02039 02040 virtual bool 02041 releaseCachedString(XalanDOMString& theString) = 0; 02042 02043 02044 virtual void 02045 getNodeSetByKey( 02046 XalanDocument* doc, 02047 const XalanQName& qname, 02048 const XalanDOMString& ref, 02049 MutableNodeRefList& nodelist) = 0; 02050 02051 virtual void 02052 getNodeSetByKey( 02053 XalanDocument* doc, 02054 const XalanDOMString& name, 02055 const XalanDOMString& ref, 02056 const LocatorType* locator, 02057 MutableNodeRefList& nodelist) = 0; 02058 02059 virtual const XObjectPtr 02060 getVariable( 02061 const XalanQName& name, 02062 const LocatorType* locator = 0) = 0; 02063 02064 virtual const PrefixResolver* 02065 getPrefixResolver() const = 0; 02066 02067 virtual void 02068 setPrefixResolver(const PrefixResolver* thePrefixResolver) = 0; 02069 02070 virtual const XalanDOMString* 02071 getNamespaceForPrefix(const XalanDOMString& prefix) const = 0; 02072 02073 virtual const XalanDOMString& 02074 findURIFromDoc(const XalanDocument* owner) const = 0; 02075 02076 virtual const XalanDOMString& 02077 getUnparsedEntityURI( 02078 const XalanDOMString& theName, 02079 const XalanDocument& theDocument) const = 0; 02080 02081 virtual bool 02082 shouldStripSourceNode(const XalanText& node) = 0; 02083 02084 virtual XalanDocument* 02085 getSourceDocument(const XalanDOMString& theURI) const = 0; 02086 02087 virtual void 02088 setSourceDocument( 02089 const XalanDOMString& theURI, 02090 XalanDocument* theDocument) = 0; 02091 02092 virtual void 02093 formatNumber( 02094 double number, 02095 const XalanDOMString& pattern, 02096 XalanDOMString& theResult, 02097 const XalanNode* context = 0, 02098 const LocatorType* locator = 0) = 0; 02099 02100 virtual void 02101 formatNumber( 02102 double number, 02103 const XalanDOMString& pattern, 02104 const XalanDOMString& dfsName, 02105 XalanDOMString& theResult, 02106 const XalanNode* context = 0, 02107 const LocatorType* locator = 0) = 0; 02108 02109 // These interfaces are inherited from ExecutionContext... 02110 02111 virtual void 02112 error( 02113 const XalanDOMString& msg, 02114 const XalanNode* sourceNode, 02115 const LocatorType* locator) const = 0; 02116 02117 virtual void 02118 warn( 02119 const XalanDOMString& msg, 02120 const XalanNode* sourceNode = 0, 02121 const LocatorType* locator = 0) const = 0; 02122 02123 virtual void 02124 message( 02125 const XalanDOMString& msg, 02126 const XalanNode* sourceNode = 0, 02127 const LocatorType* locator = 0) const = 0; 02128 02129 #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) 02130 protected: 02136 virtual FormatterToText* 02137 borrowFormatterToText() = 0; 02138 02145 virtual bool 02146 returnFormatterToText(FormatterToText* theFormatter) = 0; 02147 #endif 02148 }; 02149 02150 02151 02152 XALAN_CPP_NAMESPACE_END 02153 02154 02155 02156 #endif // STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSLT Processor Version 1.9 |
|