00001 /* 00002 * The Apache Software License, Version 1.1 00003 * 00004 * 00005 * Copyright (c) 1999-2002 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 #include <xalanc/XPath/ResultTreeFragBase.hpp> 00085 00086 00087 00088 XALAN_CPP_NAMESPACE_BEGIN 00089 00090 00091 00092 class XalanDecimalFormatSymbols; 00093 class PrefixResolver; 00094 class XalanQName; 00095 class XObject; 00096 class XObjectPtr; 00097 class XObjectFactory; 00098 class XalanDocument; 00099 class XalanElement; 00100 class XalanNode; 00101 class XalanText; 00102 00103 00104 00105 // 00106 // An abstract class which provides support for executing XPath functions 00107 // and extension functions. 00108 // 00109 00110 class XALAN_XPATH_EXPORT XPathExecutionContext : public ExecutionContext 00111 { 00112 public: 00113 00114 #if defined(XALAN_NO_STD_NAMESPACE) 00115 typedef vector<XObjectPtr> XObjectArgVectorType; 00116 #else 00117 typedef std::vector<XObjectPtr> XObjectArgVectorType; 00118 #endif 00119 00120 typedef NodeRefListBase::size_type size_type; 00121 00122 explicit 00123 XPathExecutionContext(XObjectFactory* theXObjectFactory = 0); 00124 00125 virtual 00126 ~XPathExecutionContext(); 00127 00132 virtual void 00133 reset() = 0; 00134 00140 virtual XalanNode* 00141 getCurrentNode() const = 0; 00142 00148 virtual void 00149 setCurrentNode(XalanNode* theCurrentNode) = 0; 00150 00151 class CurrentNodeSetAndRestore 00152 { 00153 public: 00154 00155 CurrentNodeSetAndRestore( 00156 XPathExecutionContext& theExecutionContext, 00157 XalanNode* theNewNode) : 00158 m_executionContext(theExecutionContext), 00159 m_savedNode(theExecutionContext.getCurrentNode()) 00160 { 00161 theExecutionContext.setCurrentNode(theNewNode); 00162 } 00163 00164 CurrentNodeSetAndRestore( 00165 XPathExecutionContext& theExecutionContext, 00166 XalanNode* theOldNode, 00167 XalanNode* theNewNode) : 00168 m_executionContext(theExecutionContext), 00169 m_savedNode(theOldNode) 00170 { 00171 assert(theExecutionContext.getCurrentNode() == theOldNode); 00172 00173 theExecutionContext.setCurrentNode(theNewNode); 00174 } 00175 00176 ~CurrentNodeSetAndRestore() 00177 { 00178 m_executionContext.setCurrentNode(m_savedNode); 00179 } 00180 00181 private: 00182 00183 XPathExecutionContext& m_executionContext; 00184 XalanNode* const m_savedNode; 00185 }; 00186 00192 XObjectFactory& 00193 getXObjectFactory() const 00194 { 00195 assert(m_xobjectFactory != 0); 00196 00197 return *m_xobjectFactory; 00198 } 00199 00207 virtual bool 00208 isNodeAfter( 00209 const XalanNode& node1, 00210 const XalanNode& node2) const = 0; 00211 00217 virtual const NodeRefListBase& 00218 getContextNodeList() const = 0; 00219 00225 virtual void 00226 setContextNodeList(const NodeRefListBase& theList) = 0; 00227 00228 class ContextNodeListSetAndRestore 00229 { 00230 public: 00231 00232 ContextNodeListSetAndRestore( 00233 XPathExecutionContext& theExecutionContext, 00234 const NodeRefListBase& theNodeList) : 00235 m_executionContext(theExecutionContext), 00236 m_savedNodeList(theExecutionContext.getContextNodeList()) 00237 { 00238 m_executionContext.setContextNodeList(theNodeList); 00239 } 00240 00241 ~ContextNodeListSetAndRestore() 00242 { 00243 m_executionContext.setContextNodeList(m_savedNodeList); 00244 } 00245 00246 private: 00247 00248 XPathExecutionContext& m_executionContext; 00249 const NodeRefListBase& m_savedNodeList; 00250 }; 00251 00252 /* 00253 * Get the count of nodes in the current context node list. 00254 * 00255 * @return length of list 00256 */ 00257 virtual size_type 00258 getContextNodeListLength() const = 0; 00259 00260 /* 00261 * Get the position of the node in the current context node list. 00262 * Note that this is 1-based indexing (XPath/XSLT-style), not 0-based. 00263 * Thus, 0 will be returned if the node was not found. 00264 * 00265 * @return position in list 00266 */ 00267 virtual size_type 00268 getContextNodeListPosition(const XalanNode& contextNode) const = 0; 00269 00277 virtual bool 00278 elementAvailable(const XalanQName& theQName) const = 0; 00279 00289 virtual bool 00290 elementAvailable( 00291 const XalanDOMString& theName, 00292 const LocatorType* locator) const = 0; 00293 00301 virtual bool 00302 functionAvailable(const XalanQName& theQName) const = 0; 00303 00312 virtual bool 00313 functionAvailable( 00314 const XalanDOMString& theName, 00315 const LocatorType* locator) const = 0; 00316 00327 virtual const XObjectPtr 00328 extFunction( 00329 const XalanDOMString& theNamespace, 00330 const XalanDOMString& functionName, 00331 XalanNode* context, 00332 const XObjectArgVectorType& argVec, 00333 const LocatorType* locator) = 0; 00334 00342 virtual XalanDocument* 00343 parseXML( 00344 const XalanDOMString& urlString, 00345 const XalanDOMString& base) const = 0; 00346 00352 virtual MutableNodeRefList* 00353 borrowMutableNodeRefList() = 0; 00354 00361 virtual bool 00362 returnMutableNodeRefList(MutableNodeRefList* theList) = 0; 00363 00364 class BorrowReturnMutableNodeRefList 00365 { 00366 public: 00367 00368 BorrowReturnMutableNodeRefList(XPathExecutionContext& executionContext) : 00369 m_xpathExecutionContext(&executionContext), 00370 m_mutableNodeRefList(executionContext.borrowMutableNodeRefList()) 00371 { 00372 assert(m_mutableNodeRefList != 0); 00373 } 00374 00375 // N.B. Non-const copy constructor semantics (like std::auto_ptr) 00376 BorrowReturnMutableNodeRefList(const BorrowReturnMutableNodeRefList& theSource) : 00377 m_xpathExecutionContext(theSource.m_xpathExecutionContext), 00378 m_mutableNodeRefList(theSource.m_mutableNodeRefList) 00379 { 00380 assert(m_mutableNodeRefList != 0); 00381 00382 ((BorrowReturnMutableNodeRefList&)theSource).m_mutableNodeRefList = 0; 00383 } 00384 00385 ~BorrowReturnMutableNodeRefList() 00386 { 00387 release(); 00388 } 00389 00390 MutableNodeRefList& 00391 operator*() const 00392 { 00393 assert(m_mutableNodeRefList != 0); 00394 00395 return *m_mutableNodeRefList; 00396 } 00397 00398 MutableNodeRefList* 00399 get() const 00400 { 00401 return m_mutableNodeRefList; 00402 } 00403 00404 MutableNodeRefList* 00405 operator->() const 00406 { 00407 return get(); 00408 } 00409 00410 void 00411 release() 00412 { 00413 assert(m_xpathExecutionContext != 0); 00414 00415 if (m_mutableNodeRefList != 0) 00416 { 00417 m_xpathExecutionContext->returnMutableNodeRefList(m_mutableNodeRefList); 00418 00419 m_mutableNodeRefList = 0; 00420 } 00421 } 00422 00423 BorrowReturnMutableNodeRefList 00424 clone() const 00425 { 00426 assert(m_xpathExecutionContext != 0); 00427 00428 BorrowReturnMutableNodeRefList theResult(*m_xpathExecutionContext); 00429 00430 *theResult = *m_mutableNodeRefList; 00431 00432 return theResult; 00433 } 00434 00435 // N.B. Non-const assignment operator semantics. 00436 BorrowReturnMutableNodeRefList& 00437 operator=(BorrowReturnMutableNodeRefList& theRHS) 00438 { 00439 release(); 00440 00441 m_xpathExecutionContext = theRHS.m_xpathExecutionContext; 00442 00443 m_mutableNodeRefList = theRHS.m_mutableNodeRefList; 00444 00445 theRHS.m_mutableNodeRefList = 0; 00446 00447 return *this; 00448 } 00449 00450 private: 00451 00452 XPathExecutionContext* m_xpathExecutionContext; 00453 00454 MutableNodeRefList* m_mutableNodeRefList; 00455 }; 00456 00462 virtual XalanDOMString& 00463 getCachedString() = 0; 00464 00472 virtual bool 00473 releaseCachedString(XalanDOMString& theString) = 0; 00474 00475 class GetAndReleaseCachedString 00476 { 00477 public: 00478 00479 GetAndReleaseCachedString(XPathExecutionContext& theExecutionContext) : 00480 m_executionContext(&theExecutionContext), 00481 m_string(&theExecutionContext.getCachedString()) 00482 { 00483 } 00484 00485 // Note non-const copy semantics... 00486 GetAndReleaseCachedString(GetAndReleaseCachedString& theSource) : 00487 m_executionContext(theSource.m_executionContext), 00488 m_string(theSource.m_string) 00489 { 00490 theSource.m_string = 0; 00491 } 00492 00493 ~GetAndReleaseCachedString() 00494 { 00495 if (m_string != 0) 00496 { 00497 m_executionContext->releaseCachedString(*m_string); 00498 } 00499 } 00500 00501 XalanDOMString& 00502 get() const 00503 { 00504 assert(m_string != 0); 00505 00506 return *m_string; 00507 } 00508 00509 XPathExecutionContext& 00510 getExecutionContext() const 00511 { 00512 return *m_executionContext; 00513 } 00514 00515 private: 00516 00517 // Not implemented... 00518 GetAndReleaseCachedString& 00519 operator=(const GetAndReleaseCachedString&); 00520 00521 00522 // Data members... 00523 XPathExecutionContext* m_executionContext; 00524 00525 XalanDOMString* m_string; 00526 }; 00527 00533 virtual MutableNodeRefList* 00534 createMutableNodeRefList() const = 0; 00535 00546 virtual void 00547 getNodeSetByKey( 00548 XalanDocument* doc, 00549 const XalanQName& qname, 00550 const XalanDOMString& ref, 00551 MutableNodeRefList& nodelist) = 0; 00552 00565 virtual void 00566 getNodeSetByKey( 00567 XalanDocument* doc, 00568 const XalanDOMString& name, 00569 const XalanDOMString& ref, 00570 const LocatorType* locator, 00571 MutableNodeRefList& nodelist) = 0; 00572 00580 virtual const XObjectPtr 00581 getVariable( 00582 const XalanQName& name, 00583 const LocatorType* locator = 0) = 0; 00584 00590 virtual const PrefixResolver* 00591 getPrefixResolver() const = 0; 00592 00598 virtual void 00599 setPrefixResolver(const PrefixResolver* thePrefixResolver) = 0; 00600 00601 class PrefixResolverSetAndRestore 00602 { 00603 public: 00604 00605 PrefixResolverSetAndRestore( 00606 XPathExecutionContext& theExecutionContext, 00607 const PrefixResolver* theResolver) : 00608 m_executionContext(theExecutionContext), 00609 m_savedResolver(theExecutionContext.getPrefixResolver()) 00610 { 00611 m_executionContext.setPrefixResolver(theResolver); 00612 } 00613 00614 PrefixResolverSetAndRestore( 00615 XPathExecutionContext& theExecutionContext, 00616 const PrefixResolver* theOldResolver, 00617 const PrefixResolver* theNewResolver) : 00618 m_executionContext(theExecutionContext), 00619 m_savedResolver(theOldResolver) 00620 { 00621 m_executionContext.setPrefixResolver(theNewResolver); 00622 } 00623 00624 ~PrefixResolverSetAndRestore() 00625 { 00626 m_executionContext.setPrefixResolver(m_savedResolver); 00627 } 00628 00629 private: 00630 00631 XPathExecutionContext& m_executionContext; 00632 const PrefixResolver* const m_savedResolver; 00633 }; 00634 00641 virtual const XalanDOMString* 00642 getNamespaceForPrefix(const XalanDOMString& prefix) const = 0; 00643 00651 virtual XalanDOMString 00652 findURIFromDoc(const XalanDocument* owner) const = 0; 00653 00664 virtual const XalanDOMString& 00665 getUnparsedEntityURI( 00666 const XalanDOMString& theName, 00667 const XalanDocument& theDocument) const = 0; 00668 00679 virtual bool 00680 shouldStripSourceNode(const XalanNode& node) = 0; 00681 00689 virtual bool 00690 getThrowFoundIndex() const = 0; 00691 00699 virtual void 00700 setThrowFoundIndex(bool fThrow) = 0; 00701 00702 virtual XalanDocument* 00703 getSourceDocument(const XalanDOMString& theURI) const = 0; 00704 00711 virtual void 00712 setSourceDocument( 00713 const XalanDOMString& theURI, 00714 XalanDocument* theDocument) = 0; 00715 00716 00724 virtual const XalanDecimalFormatSymbols* 00725 getDecimalFormatSymbols(const XalanQName& qname) = 0; 00726 00727 // These interfaces are inherited from ExecutionContext... 00728 00729 virtual void 00730 error( 00731 const XalanDOMString& msg, 00732 const XalanNode* sourceNode = 0, 00733 const LocatorType* locator = 0) const = 0; 00734 00735 virtual void 00736 error( 00737 const char* msg, 00738 const XalanNode* sourceNode = 0, 00739 const LocatorType* locator = 0) const = 0; 00740 00741 virtual void 00742 warn( 00743 const XalanDOMString& msg, 00744 const XalanNode* sourceNode = 0, 00745 const LocatorType* locator = 0) const = 0; 00746 00747 virtual void 00748 warn( 00749 const char* msg, 00750 const XalanNode* sourceNode = 0, 00751 const LocatorType* locator = 0) const = 0; 00752 00753 virtual void 00754 message( 00755 const XalanDOMString& msg, 00756 const XalanNode* sourceNode = 0, 00757 const LocatorType* locator = 0) const = 0; 00758 00759 virtual void 00760 message( 00761 const char* msg, 00762 const XalanNode* sourceNode = 0, 00763 const LocatorType* locator = 0) const = 0; 00764 00765 protected: 00766 00767 XObjectFactory* m_xobjectFactory; 00768 }; 00769 00770 00771 00772 XALAN_CPP_NAMESPACE_END 00773 00774 00775 00776 #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.6 |
|