00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999-2004 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(XPATHEXECUTIONCONTEXT_HEADER_GUARD_1357924680) 00060 #define XPATHEXECUTIONCONTEXT_HEADER_GUARD_1357924680 00061 00062 00063 00064 // Base include file. Must be first. 00065 #include <xalanc/XPath/XPathDefinitions.hpp> 00066 00067 00068 00069 #include <cassert> 00070 #include <vector> 00071 00072 00073 00074 #include <xalanc/XalanDOM/XalanDOMString.hpp> 00075 00076 00077 00078 // Base class header file... 00079 #include <xalanc/PlatformSupport/ExecutionContext.hpp> 00080 00081 00082 00083 #include <xalanc/XPath/MutableNodeRefList.hpp> 00084 00085 00086 00087 XALAN_CPP_NAMESPACE_BEGIN 00088 00089 00090 00091 class XalanDecimalFormatSymbols; 00092 class PrefixResolver; 00093 class XalanQName; 00094 class XObject; 00095 class XObjectPtr; 00096 class XObjectFactory; 00097 class XalanDocument; 00098 class XalanElement; 00099 class XalanNode; 00100 class XalanText; 00101 00102 00103 00104 // 00105 // An abstract class which provides support for executing XPath functions 00106 // and extension functions. 00107 // 00108 00109 class XALAN_XPATH_EXPORT XPathExecutionContext : public ExecutionContext 00110 { 00111 public: 00112 00113 #if defined(XALAN_NO_STD_NAMESPACE) 00114 typedef vector<XObjectPtr> XObjectArgVectorType; 00115 #else 00116 typedef std::vector<XObjectPtr> XObjectArgVectorType; 00117 #endif 00118 00119 typedef NodeRefListBase::size_type size_type; 00120 00121 explicit 00122 XPathExecutionContext(XObjectFactory* theXObjectFactory = 0); 00123 00124 virtual 00125 ~XPathExecutionContext(); 00126 00131 virtual void 00132 reset() = 0; 00133 00139 virtual XalanNode* 00140 getCurrentNode() const = 0; 00141 00147 virtual void 00148 pushCurrentNode(XalanNode* theCurrentNode) = 0; 00149 00153 virtual void 00154 popCurrentNode() = 0; 00155 00156 class CurrentNodePushAndPop 00157 { 00158 public: 00159 00160 CurrentNodePushAndPop( 00161 XPathExecutionContext& theExecutionContext, 00162 XalanNode* theNewNode) : 00163 m_executionContext(theExecutionContext) 00164 { 00165 theExecutionContext.pushCurrentNode(theNewNode); 00166 } 00167 00168 ~CurrentNodePushAndPop() 00169 { 00170 m_executionContext.popCurrentNode(); 00171 } 00172 00173 private: 00174 00175 XPathExecutionContext& m_executionContext; 00176 }; 00177 00183 XObjectFactory& 00184 getXObjectFactory() const 00185 { 00186 assert(m_xobjectFactory != 0); 00187 00188 return *m_xobjectFactory; 00189 } 00190 00198 virtual bool 00199 isNodeAfter( 00200 const XalanNode& node1, 00201 const XalanNode& node2) const = 0; 00202 00208 virtual void 00209 pushContextNodeList(const NodeRefListBase& theList) = 0; 00210 00214 virtual void 00215 popContextNodeList() = 0; 00216 00217 class ContextNodeListPushAndPop 00218 { 00219 public: 00220 00221 ContextNodeListPushAndPop( 00222 XPathExecutionContext& theExecutionContext, 00223 const NodeRefListBase& theNodeList) : 00224 m_executionContext(theExecutionContext) 00225 { 00226 m_executionContext.pushContextNodeList(theNodeList); 00227 } 00228 00229 ~ContextNodeListPushAndPop() 00230 { 00231 m_executionContext.popContextNodeList(); 00232 } 00233 00234 private: 00235 00236 XPathExecutionContext& m_executionContext; 00237 }; 00238 00244 virtual const NodeRefListBase& 00245 getContextNodeList() const = 0; 00246 00247 /* 00248 * Get the count of nodes in the current context node list. 00249 * 00250 * @return length of list 00251 */ 00252 virtual size_type 00253 getContextNodeListLength() const = 0; 00254 00255 /* 00256 * Get the position of the node in the current context node list. 00257 * Note that this is 1-based indexing (XPath/XSLT-style), not 0-based. 00258 * Thus, 0 will be returned if the node was not found. 00259 * 00260 * @return position in list 00261 */ 00262 virtual size_type 00263 getContextNodeListPosition(const XalanNode& contextNode) const = 0; 00264 00272 virtual bool 00273 elementAvailable(const XalanQName& theQName) const = 0; 00274 00284 virtual bool 00285 elementAvailable( 00286 const XalanDOMString& theName, 00287 const LocatorType* locator) const = 0; 00288 00296 virtual bool 00297 functionAvailable(const XalanQName& theQName) const = 0; 00298 00307 virtual bool 00308 functionAvailable( 00309 const XalanDOMString& theName, 00310 const LocatorType* locator) const = 0; 00311 00322 virtual const XObjectPtr 00323 extFunction( 00324 const XalanDOMString& theNamespace, 00325 const XalanDOMString& functionName, 00326 XalanNode* context, 00327 const XObjectArgVectorType& argVec, 00328 const LocatorType* locator) = 0; 00329 00337 virtual XalanDocument* 00338 parseXML( 00339 const XalanDOMString& urlString, 00340 const XalanDOMString& base) const = 0; 00341 00347 virtual MutableNodeRefList* 00348 borrowMutableNodeRefList() = 0; 00349 00356 virtual bool 00357 returnMutableNodeRefList(MutableNodeRefList* theList) = 0; 00358 00359 class BorrowReturnMutableNodeRefList 00360 { 00361 public: 00362 00363 BorrowReturnMutableNodeRefList(XPathExecutionContext& executionContext) : 00364 m_xpathExecutionContext(&executionContext), 00365 m_mutableNodeRefList(executionContext.borrowMutableNodeRefList()) 00366 { 00367 assert(m_mutableNodeRefList != 0); 00368 } 00369 00370 // N.B. Non-const copy constructor semantics (like std::auto_ptr) 00371 BorrowReturnMutableNodeRefList(const BorrowReturnMutableNodeRefList& theSource) : 00372 m_xpathExecutionContext(theSource.m_xpathExecutionContext), 00373 m_mutableNodeRefList(theSource.m_mutableNodeRefList) 00374 { 00375 assert(m_mutableNodeRefList != 0); 00376 00377 ((BorrowReturnMutableNodeRefList&)theSource).m_mutableNodeRefList = 0; 00378 } 00379 00380 ~BorrowReturnMutableNodeRefList() 00381 { 00382 release(); 00383 } 00384 00385 MutableNodeRefList& 00386 operator*() const 00387 { 00388 assert(m_mutableNodeRefList != 0); 00389 00390 return *m_mutableNodeRefList; 00391 } 00392 00393 MutableNodeRefList* 00394 get() const 00395 { 00396 return m_mutableNodeRefList; 00397 } 00398 00399 MutableNodeRefList* 00400 operator->() const 00401 { 00402 return get(); 00403 } 00404 00405 void 00406 release() 00407 { 00408 assert(m_xpathExecutionContext != 0); 00409 00410 if (m_mutableNodeRefList != 0) 00411 { 00412 m_xpathExecutionContext->returnMutableNodeRefList(m_mutableNodeRefList); 00413 00414 m_mutableNodeRefList = 0; 00415 } 00416 } 00417 00418 BorrowReturnMutableNodeRefList 00419 clone() const 00420 { 00421 assert(m_xpathExecutionContext != 0); 00422 00423 BorrowReturnMutableNodeRefList theResult(*m_xpathExecutionContext); 00424 00425 *theResult = *m_mutableNodeRefList; 00426 00427 return theResult; 00428 } 00429 00430 // N.B. Non-const assignment operator semantics. 00431 BorrowReturnMutableNodeRefList& 00432 operator=(BorrowReturnMutableNodeRefList& theRHS) 00433 { 00434 release(); 00435 00436 m_xpathExecutionContext = theRHS.m_xpathExecutionContext; 00437 00438 m_mutableNodeRefList = theRHS.m_mutableNodeRefList; 00439 00440 theRHS.m_mutableNodeRefList = 0; 00441 00442 return *this; 00443 } 00444 00445 private: 00446 00447 XPathExecutionContext* m_xpathExecutionContext; 00448 00449 MutableNodeRefList* m_mutableNodeRefList; 00450 }; 00451 00457 virtual XalanDOMString& 00458 getCachedString() = 0; 00459 00467 virtual bool 00468 releaseCachedString(XalanDOMString& theString) = 0; 00469 00470 class GetAndReleaseCachedString 00471 { 00472 public: 00473 00474 GetAndReleaseCachedString(XPathExecutionContext& theExecutionContext) : 00475 m_executionContext(&theExecutionContext), 00476 m_string(&theExecutionContext.getCachedString()) 00477 { 00478 } 00479 00480 // Note non-const copy semantics... 00481 GetAndReleaseCachedString(GetAndReleaseCachedString& theSource) : 00482 m_executionContext(theSource.m_executionContext), 00483 m_string(theSource.m_string) 00484 { 00485 theSource.m_string = 0; 00486 } 00487 00488 ~GetAndReleaseCachedString() 00489 { 00490 if (m_string != 0) 00491 { 00492 m_executionContext->releaseCachedString(*m_string); 00493 } 00494 } 00495 00496 XalanDOMString& 00497 get() const 00498 { 00499 assert(m_string != 0); 00500 00501 return *m_string; 00502 } 00503 00504 XPathExecutionContext& 00505 getExecutionContext() const 00506 { 00507 return *m_executionContext; 00508 } 00509 00510 private: 00511 00512 // Not implemented... 00513 GetAndReleaseCachedString& 00514 operator=(const GetAndReleaseCachedString&); 00515 00516 00517 // Data members... 00518 XPathExecutionContext* m_executionContext; 00519 00520 XalanDOMString* m_string; 00521 }; 00522 00528 virtual MutableNodeRefList* 00529 createMutableNodeRefList() const = 0; 00530 00541 virtual void 00542 getNodeSetByKey( 00543 XalanDocument* doc, 00544 const XalanQName& qname, 00545 const XalanDOMString& ref, 00546 MutableNodeRefList& nodelist) = 0; 00547 00560 virtual void 00561 getNodeSetByKey( 00562 XalanDocument* doc, 00563 const XalanDOMString& name, 00564 const XalanDOMString& ref, 00565 const LocatorType* locator, 00566 MutableNodeRefList& nodelist) = 0; 00567 00575 virtual const XObjectPtr 00576 getVariable( 00577 const XalanQName& name, 00578 const LocatorType* locator = 0) = 0; 00579 00585 virtual const PrefixResolver* 00586 getPrefixResolver() const = 0; 00587 00593 virtual void 00594 setPrefixResolver(const PrefixResolver* thePrefixResolver) = 0; 00595 00596 class PrefixResolverSetAndRestore 00597 { 00598 public: 00599 00600 PrefixResolverSetAndRestore( 00601 XPathExecutionContext& theExecutionContext, 00602 const PrefixResolver* theResolver) : 00603 m_executionContext(theExecutionContext), 00604 m_savedResolver(theExecutionContext.getPrefixResolver()) 00605 { 00606 m_executionContext.setPrefixResolver(theResolver); 00607 } 00608 00609 PrefixResolverSetAndRestore( 00610 XPathExecutionContext& theExecutionContext, 00611 const PrefixResolver* theOldResolver, 00612 const PrefixResolver* theNewResolver) : 00613 m_executionContext(theExecutionContext), 00614 m_savedResolver(theOldResolver) 00615 { 00616 m_executionContext.setPrefixResolver(theNewResolver); 00617 } 00618 00619 ~PrefixResolverSetAndRestore() 00620 { 00621 m_executionContext.setPrefixResolver(m_savedResolver); 00622 } 00623 00624 private: 00625 00626 XPathExecutionContext& m_executionContext; 00627 const PrefixResolver* const m_savedResolver; 00628 }; 00629 00636 virtual const XalanDOMString* 00637 getNamespaceForPrefix(const XalanDOMString& prefix) const = 0; 00638 00646 virtual XalanDOMString 00647 findURIFromDoc(const XalanDocument* owner) const = 0; 00648 00659 virtual const XalanDOMString& 00660 getUnparsedEntityURI( 00661 const XalanDOMString& theName, 00662 const XalanDocument& theDocument) const = 0; 00663 00674 virtual bool 00675 shouldStripSourceNode(const XalanNode& node) = 0; 00676 00683 virtual XalanDocument* 00684 getSourceDocument(const XalanDOMString& theURI) const = 0; 00685 00692 virtual void 00693 setSourceDocument( 00694 const XalanDOMString& theURI, 00695 XalanDocument* theDocument) = 0; 00696 00697 00705 virtual const XalanDecimalFormatSymbols* 00706 getDecimalFormatSymbols(const XalanQName& qname) = 0; 00707 00708 // These interfaces are inherited from ExecutionContext... 00709 00710 virtual void 00711 error( 00712 const XalanDOMString& msg, 00713 const XalanNode* sourceNode = 0, 00714 const LocatorType* locator = 0) const = 0; 00715 00716 virtual void 00717 error( 00718 const char* msg, 00719 const XalanNode* sourceNode = 0, 00720 const LocatorType* locator = 0) const = 0; 00721 00722 virtual void 00723 warn( 00724 const XalanDOMString& msg, 00725 const XalanNode* sourceNode = 0, 00726 const LocatorType* locator = 0) const = 0; 00727 00728 virtual void 00729 warn( 00730 const char* msg, 00731 const XalanNode* sourceNode = 0, 00732 const LocatorType* locator = 0) const = 0; 00733 00734 virtual void 00735 message( 00736 const XalanDOMString& msg, 00737 const XalanNode* sourceNode = 0, 00738 const LocatorType* locator = 0) const = 0; 00739 00740 virtual void 00741 message( 00742 const char* msg, 00743 const XalanNode* sourceNode = 0, 00744 const LocatorType* locator = 0) const = 0; 00745 00746 protected: 00747 00748 XObjectFactory* m_xobjectFactory; 00749 }; 00750 00751 00752 00753 XALAN_CPP_NAMESPACE_END 00754 00755 00756 00757 #endif // XPATHEXECUTIONCONTEXT_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.7 |
|