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
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
![]() |
Xalan-C++ XSL Transformer Version 1.1 |
|