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 #if !defined(EXSLT_MATHIMPL_HEADER_GUARD_1357924680) 00058 #define EXSLT_MATHIMPL_HEADER_GUARD_1357924680 00059 00060 00061 00062 #include "XalanEXSLTDefinitions.hpp" 00063 00064 00065 00066 #include <xalanc/PlatformSupport/XalanMessageLoader.hpp> 00067 00068 00069 00070 #include <xalanc/XPath/Function.hpp> 00071 00072 00073 00074 XALAN_CPP_NAMESPACE_BEGIN 00075 00076 00077 00078 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAbs : public Function 00079 { 00080 public: 00081 00082 typedef Function ParentType; 00083 00084 XalanEXSLTFunctionAbs() 00085 { 00086 } 00087 00088 virtual 00089 ~XalanEXSLTFunctionAbs() 00090 { 00091 } 00092 00093 // These methods are inherited from Function ... 00094 00095 virtual XObjectPtr 00096 execute( 00097 XPathExecutionContext& executionContext, 00098 XalanNode* context, 00099 const XObjectArgVectorType& args, 00100 const LocatorType* locator) const; 00101 00102 #if !defined(XALAN_NO_USING_DECLARATION) 00103 using ParentType::execute; 00104 #endif 00105 00106 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00107 virtual Function* 00108 #else 00109 virtual XalanEXSLTFunctionAbs* 00110 #endif 00111 clone() const 00112 { 00113 return new XalanEXSLTFunctionAbs(*this); 00114 } 00115 00116 protected: 00117 00118 const XalanDOMString 00119 getError() const; 00120 00121 private: 00122 00123 // Not implemented... 00124 XalanEXSLTFunctionAbs& 00125 operator=(const XalanEXSLTFunctionAbs&); 00126 00127 bool 00128 operator==(const XalanEXSLTFunctionAbs&) const; 00129 }; 00130 00131 00132 00133 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionRandom : public Function 00134 { 00135 public: 00136 00137 typedef Function ParentType; 00138 00139 XalanEXSLTFunctionRandom() 00140 { 00141 } 00142 00143 virtual 00144 ~XalanEXSLTFunctionRandom() 00145 { 00146 } 00147 00148 // These methods are inherited from Function ... 00149 00150 virtual XObjectPtr 00151 execute( 00152 XPathExecutionContext& executionContext, 00153 XalanNode* context, 00154 const XObjectArgVectorType& args, 00155 const LocatorType* locator) const; 00156 00157 #if !defined(XALAN_NO_USING_DECLARATION) 00158 using ParentType::execute; 00159 #endif 00160 00161 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00162 virtual Function* 00163 #else 00164 virtual XalanEXSLTFunctionRandom* 00165 #endif 00166 clone() const 00167 { 00168 return new XalanEXSLTFunctionRandom(*this); 00169 } 00170 00171 protected: 00172 00173 const XalanDOMString 00174 getError() const; 00175 00176 private: 00177 00178 // Not implemented... 00179 XalanEXSLTFunctionRandom& 00180 operator=(const XalanEXSLTFunctionRandom&); 00181 00182 bool 00183 operator==(const XalanEXSLTFunctionRandom&) const; 00184 }; 00185 00186 00187 00188 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAcos : public Function 00189 { 00190 public: 00191 00192 typedef Function ParentType; 00193 00194 XalanEXSLTFunctionAcos() 00195 { 00196 } 00197 00198 virtual 00199 ~XalanEXSLTFunctionAcos() 00200 { 00201 } 00202 00203 // These methods are inherited from Function ... 00204 00205 virtual XObjectPtr 00206 execute( 00207 XPathExecutionContext& executionContext, 00208 XalanNode* context, 00209 const XObjectArgVectorType& args, 00210 const LocatorType* locator) const; 00211 00212 #if !defined(XALAN_NO_USING_DECLARATION) 00213 using ParentType::execute; 00214 #endif 00215 00216 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00217 virtual Function* 00218 #else 00219 virtual XalanEXSLTFunctionAcos* 00220 #endif 00221 clone() const 00222 { 00223 return new XalanEXSLTFunctionAcos(*this); 00224 } 00225 00226 protected: 00227 00228 const XalanDOMString 00229 getError() const; 00230 00231 private: 00232 00233 // Not implemented... 00234 XalanEXSLTFunctionAcos& 00235 operator=(const XalanEXSLTFunctionAcos&); 00236 00237 bool 00238 operator==(const XalanEXSLTFunctionAcos&) const; 00239 }; 00240 00241 00242 00243 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAsin : public Function 00244 { 00245 public: 00246 00247 typedef Function ParentType; 00248 00249 XalanEXSLTFunctionAsin() 00250 { 00251 } 00252 00253 virtual 00254 ~XalanEXSLTFunctionAsin() 00255 { 00256 } 00257 00258 // These methods are inherited from Function ... 00259 00260 virtual XObjectPtr 00261 execute( 00262 XPathExecutionContext& executionContext, 00263 XalanNode* context, 00264 const XObjectArgVectorType& args, 00265 const LocatorType* locator) const; 00266 00267 #if !defined(XALAN_NO_USING_DECLARATION) 00268 using ParentType::execute; 00269 #endif 00270 00271 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00272 virtual Function* 00273 #else 00274 virtual XalanEXSLTFunctionAsin* 00275 #endif 00276 clone() const 00277 { 00278 return new XalanEXSLTFunctionAsin(*this); 00279 } 00280 00281 protected: 00282 00283 const XalanDOMString 00284 getError() const; 00285 00286 private: 00287 00288 // Not implemented... 00289 XalanEXSLTFunctionAsin& 00290 operator=(const XalanEXSLTFunctionAsin&); 00291 00292 bool 00293 operator==(const XalanEXSLTFunctionAsin&) const; 00294 }; 00295 00296 00297 00298 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAtan : public Function 00299 { 00300 public: 00301 00302 typedef Function ParentType; 00303 00304 XalanEXSLTFunctionAtan() 00305 { 00306 } 00307 00308 virtual 00309 ~XalanEXSLTFunctionAtan() 00310 { 00311 } 00312 00313 // These methods are inherited from Function ... 00314 00315 virtual XObjectPtr 00316 execute( 00317 XPathExecutionContext& executionContext, 00318 XalanNode* context, 00319 const XObjectArgVectorType& args, 00320 const LocatorType* locator) const; 00321 00322 #if !defined(XALAN_NO_USING_DECLARATION) 00323 using ParentType::execute; 00324 #endif 00325 00326 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00327 virtual Function* 00328 #else 00329 virtual XalanEXSLTFunctionAtan* 00330 #endif 00331 clone() const 00332 { 00333 return new XalanEXSLTFunctionAtan(*this); 00334 } 00335 00336 protected: 00337 00338 const XalanDOMString 00339 getError() const; 00340 00341 private: 00342 00343 // Not implemented... 00344 XalanEXSLTFunctionAtan& 00345 operator=(const XalanEXSLTFunctionAtan&); 00346 00347 bool 00348 operator==(const XalanEXSLTFunctionAtan&) const; 00349 }; 00350 00351 00352 00353 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAtan2 : public Function 00354 { 00355 public: 00356 00357 typedef Function ParentType; 00358 00359 XalanEXSLTFunctionAtan2() 00360 { 00361 } 00362 00363 virtual 00364 ~XalanEXSLTFunctionAtan2() 00365 { 00366 } 00367 00368 // These methods are inherited from Function ... 00369 00370 virtual XObjectPtr 00371 execute( 00372 XPathExecutionContext& executionContext, 00373 XalanNode* context, 00374 const XObjectArgVectorType& args, 00375 const LocatorType* locator) const; 00376 00377 #if !defined(XALAN_NO_USING_DECLARATION) 00378 using ParentType::execute; 00379 #endif 00380 00381 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00382 virtual Function* 00383 #else 00384 virtual XalanEXSLTFunctionAtan2* 00385 #endif 00386 clone() const 00387 { 00388 return new XalanEXSLTFunctionAtan2(*this); 00389 } 00390 00391 protected: 00392 00393 const XalanDOMString 00394 getError() const; 00395 00396 private: 00397 00398 // Not implemented... 00399 XalanEXSLTFunctionAtan2& 00400 operator=(const XalanEXSLTFunctionAtan2&); 00401 00402 bool 00403 operator==(const XalanEXSLTFunctionAtan2&) const; 00404 }; 00405 00406 00407 00408 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionConstant : public Function 00409 { 00410 public: 00411 00412 typedef Function ParentType; 00413 00414 XalanEXSLTFunctionConstant() 00415 { 00416 } 00417 00418 virtual 00419 ~XalanEXSLTFunctionConstant() 00420 { 00421 } 00422 00423 // These methods are inherited from Function ... 00424 00425 virtual XObjectPtr 00426 execute( 00427 XPathExecutionContext& executionContext, 00428 XalanNode* context, 00429 const XObjectArgVectorType& args, 00430 const LocatorType* locator) const; 00431 00432 #if !defined(XALAN_NO_USING_DECLARATION) 00433 using ParentType::execute; 00434 #endif 00435 00436 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00437 virtual Function* 00438 #else 00439 virtual XalanEXSLTFunctionConstant* 00440 #endif 00441 clone() const 00442 { 00443 return new XalanEXSLTFunctionConstant(*this); 00444 } 00445 00446 protected: 00447 00448 const XalanDOMString 00449 getError() const 00450 { 00451 return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"constant()"); 00452 00453 } 00454 00455 private: 00456 00457 static const XalanDOMChar s_eString[]; 00458 static const XalanDOMChar s_ln10String[]; 00459 static const XalanDOMChar s_ln2String[]; 00460 static const XalanDOMChar s_log2EString[]; 00461 static const XalanDOMChar s_piString[]; 00462 static const XalanDOMChar s_sqrt1_2String[]; 00463 static const XalanDOMChar s_sqrt2String[]; 00464 00465 static const double s_eValues[]; 00466 static const double s_ln10Values[]; 00467 static const double s_ln2Values[]; 00468 static const double s_log2EValues[]; 00469 static const double s_piValues[]; 00470 static const double s_sqrt1_2Values[]; 00471 static const double s_sqrt2Values[]; 00472 00473 00474 // Not implemented... 00475 XalanEXSLTFunctionConstant& 00476 operator=(const XalanEXSLTFunctionConstant&); 00477 00478 bool 00479 operator==(const XalanEXSLTFunctionConstant&) const; 00480 }; 00481 00482 00483 00484 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionCos : public Function 00485 { 00486 public: 00487 00488 typedef Function ParentType; 00489 00490 XalanEXSLTFunctionCos() 00491 { 00492 } 00493 00494 virtual 00495 ~XalanEXSLTFunctionCos() 00496 { 00497 } 00498 00499 // These methods are inherited from Function ... 00500 00501 virtual XObjectPtr 00502 execute( 00503 XPathExecutionContext& executionContext, 00504 XalanNode* context, 00505 const XObjectArgVectorType& args, 00506 const LocatorType* locator) const; 00507 00508 #if !defined(XALAN_NO_USING_DECLARATION) 00509 using ParentType::execute; 00510 #endif 00511 00512 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00513 virtual Function* 00514 #else 00515 virtual XalanEXSLTFunctionCos* 00516 #endif 00517 clone() const 00518 { 00519 return new XalanEXSLTFunctionCos(*this); 00520 } 00521 00522 protected: 00523 00524 const XalanDOMString 00525 getError() const; 00526 00527 private: 00528 00529 // Not implemented... 00530 XalanEXSLTFunctionCos& 00531 operator=(const XalanEXSLTFunctionCos&); 00532 00533 bool 00534 operator==(const XalanEXSLTFunctionCos&) const; 00535 }; 00536 00537 00538 00539 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionExp : public Function 00540 { 00541 public: 00542 00543 typedef Function ParentType; 00544 00545 XalanEXSLTFunctionExp() 00546 { 00547 } 00548 00549 virtual 00550 ~XalanEXSLTFunctionExp() 00551 { 00552 } 00553 00554 // These methods are inherited from Function ... 00555 00556 virtual XObjectPtr 00557 execute( 00558 XPathExecutionContext& executionContext, 00559 XalanNode* context, 00560 const XObjectArgVectorType& args, 00561 const LocatorType* locator) const; 00562 00563 #if !defined(XALAN_NO_USING_DECLARATION) 00564 using ParentType::execute; 00565 #endif 00566 00567 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00568 virtual Function* 00569 #else 00570 virtual XalanEXSLTFunctionExp* 00571 #endif 00572 clone() const 00573 { 00574 return new XalanEXSLTFunctionExp(*this); 00575 } 00576 00577 protected: 00578 00579 const XalanDOMString 00580 getError() const; 00581 00582 private: 00583 00584 // Not implemented... 00585 XalanEXSLTFunctionExp& 00586 operator=(const XalanEXSLTFunctionExp&); 00587 00588 bool 00589 operator==(const XalanEXSLTFunctionExp&) const; 00590 }; 00591 00592 00593 00594 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHighest : public Function 00595 { 00596 public: 00597 00598 typedef Function ParentType; 00599 00600 XalanEXSLTFunctionHighest() 00601 { 00602 } 00603 00604 virtual 00605 ~XalanEXSLTFunctionHighest() 00606 { 00607 } 00608 00609 // These methods are inherited from Function ... 00610 00611 virtual XObjectPtr 00612 execute( 00613 XPathExecutionContext& executionContext, 00614 XalanNode* context, 00615 const XObjectArgVectorType& args, 00616 const LocatorType* locator) const; 00617 00618 #if !defined(XALAN_NO_USING_DECLARATION) 00619 using ParentType::execute; 00620 #endif 00621 00622 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00623 virtual Function* 00624 #else 00625 virtual XalanEXSLTFunctionHighest* 00626 #endif 00627 clone() const 00628 { 00629 return new XalanEXSLTFunctionHighest(*this); 00630 } 00631 00632 protected: 00633 00634 const XalanDOMString 00635 getError() const; 00636 00637 private: 00638 00639 // Not implemented... 00640 XalanEXSLTFunctionHighest& 00641 operator=(const XalanEXSLTFunctionHighest&); 00642 00643 bool 00644 operator==(const XalanEXSLTFunctionHighest&) const; 00645 }; 00646 00647 00648 00649 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLog : public Function 00650 { 00651 public: 00652 00653 typedef Function ParentType; 00654 00655 XalanEXSLTFunctionLog() 00656 { 00657 } 00658 00659 virtual 00660 ~XalanEXSLTFunctionLog() 00661 { 00662 } 00663 00664 // These methods are inherited from Function ... 00665 00666 virtual XObjectPtr 00667 execute( 00668 XPathExecutionContext& executionContext, 00669 XalanNode* context, 00670 const XObjectArgVectorType& args, 00671 const LocatorType* locator) const; 00672 00673 #if !defined(XALAN_NO_USING_DECLARATION) 00674 using ParentType::execute; 00675 #endif 00676 00677 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00678 virtual Function* 00679 #else 00680 virtual XalanEXSLTFunctionLog* 00681 #endif 00682 clone() const 00683 { 00684 return new XalanEXSLTFunctionLog(*this); 00685 } 00686 00687 protected: 00688 00689 const XalanDOMString 00690 getError() const; 00691 00692 private: 00693 00694 // Not implemented... 00695 XalanEXSLTFunctionLog& 00696 operator=(const XalanEXSLTFunctionLog&); 00697 00698 bool 00699 operator==(const XalanEXSLTFunctionLog&) const; 00700 }; 00701 00702 00703 00704 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLowest : public Function 00705 { 00706 public: 00707 00708 typedef Function ParentType; 00709 00710 XalanEXSLTFunctionLowest() 00711 { 00712 } 00713 00714 virtual 00715 ~XalanEXSLTFunctionLowest() 00716 { 00717 } 00718 00719 // These methods are inherited from Function ... 00720 00721 virtual XObjectPtr 00722 execute( 00723 XPathExecutionContext& executionContext, 00724 XalanNode* context, 00725 const XObjectArgVectorType& args, 00726 const LocatorType* locator) const; 00727 00728 #if !defined(XALAN_NO_USING_DECLARATION) 00729 using ParentType::execute; 00730 #endif 00731 00732 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00733 virtual Function* 00734 #else 00735 virtual XalanEXSLTFunctionLowest* 00736 #endif 00737 clone() const 00738 { 00739 return new XalanEXSLTFunctionLowest(*this); 00740 } 00741 00742 protected: 00743 00744 const XalanDOMString 00745 getError() const; 00746 00747 private: 00748 00749 // Not implemented... 00750 XalanEXSLTFunctionLowest& 00751 operator=(const XalanEXSLTFunctionLowest&); 00752 00753 bool 00754 operator==(const XalanEXSLTFunctionLowest&) const; 00755 }; 00756 00757 00758 00759 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMax : public Function 00760 { 00761 public: 00762 00763 typedef Function ParentType; 00764 00765 XalanEXSLTFunctionMax() 00766 { 00767 } 00768 00769 virtual 00770 ~XalanEXSLTFunctionMax() 00771 { 00772 } 00773 00774 // These methods are inherited from Function ... 00775 00776 virtual XObjectPtr 00777 execute( 00778 XPathExecutionContext& executionContext, 00779 XalanNode* context, 00780 const XObjectArgVectorType& args, 00781 const LocatorType* locator) const; 00782 00783 #if !defined(XALAN_NO_USING_DECLARATION) 00784 using ParentType::execute; 00785 #endif 00786 00787 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00788 virtual Function* 00789 #else 00790 virtual XalanEXSLTFunctionMax* 00791 #endif 00792 clone() const 00793 { 00794 return new XalanEXSLTFunctionMax(*this); 00795 } 00796 00797 protected: 00798 00799 const XalanDOMString 00800 getError() const; 00801 00802 private: 00803 00804 // Not implemented... 00805 XalanEXSLTFunctionMax& 00806 operator=(const XalanEXSLTFunctionMax&); 00807 00808 bool 00809 operator==(const XalanEXSLTFunctionMax&) const; 00810 }; 00811 00812 00813 00814 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMin : public Function 00815 { 00816 public: 00817 00818 typedef Function ParentType; 00819 00820 XalanEXSLTFunctionMin() 00821 { 00822 } 00823 00824 virtual 00825 ~XalanEXSLTFunctionMin() 00826 { 00827 } 00828 00829 // These methods are inherited from Function ... 00830 00831 virtual XObjectPtr 00832 execute( 00833 XPathExecutionContext& executionContext, 00834 XalanNode* context, 00835 const XObjectArgVectorType& args, 00836 const LocatorType* locator) const; 00837 00838 #if !defined(XALAN_NO_USING_DECLARATION) 00839 using ParentType::execute; 00840 #endif 00841 00842 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00843 virtual Function* 00844 #else 00845 virtual XalanEXSLTFunctionMin* 00846 #endif 00847 clone() const 00848 { 00849 return new XalanEXSLTFunctionMin(*this); 00850 } 00851 00852 protected: 00853 00854 const XalanDOMString 00855 getError() const; 00856 00857 private: 00858 00859 // Not implemented... 00860 XalanEXSLTFunctionMin& 00861 operator=(const XalanEXSLTFunctionMin&); 00862 00863 bool 00864 operator==(const XalanEXSLTFunctionMin&) const; 00865 }; 00866 00867 00868 00869 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionPower : public Function 00870 { 00871 public: 00872 00873 typedef Function ParentType; 00874 00875 XalanEXSLTFunctionPower() 00876 { 00877 } 00878 00879 virtual 00880 ~XalanEXSLTFunctionPower() 00881 { 00882 } 00883 00884 // These methods are inherited from Function ... 00885 00886 virtual XObjectPtr 00887 execute( 00888 XPathExecutionContext& executionContext, 00889 XalanNode* context, 00890 const XObjectArgVectorType& args, 00891 const LocatorType* locator) const; 00892 00893 #if !defined(XALAN_NO_USING_DECLARATION) 00894 using ParentType::execute; 00895 #endif 00896 00897 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00898 virtual Function* 00899 #else 00900 virtual XalanEXSLTFunctionPower* 00901 #endif 00902 clone() const 00903 { 00904 return new XalanEXSLTFunctionPower(*this); 00905 } 00906 00907 protected: 00908 00909 const XalanDOMString 00910 getError() const; 00911 00912 private: 00913 00914 // Not implemented... 00915 XalanEXSLTFunctionPower& 00916 operator=(const XalanEXSLTFunctionPower&); 00917 00918 bool 00919 operator==(const XalanEXSLTFunctionPower&) const; 00920 }; 00921 00922 00923 00924 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSin : public Function 00925 { 00926 public: 00927 00928 typedef Function ParentType; 00929 00930 XalanEXSLTFunctionSin() 00931 { 00932 } 00933 00934 virtual 00935 ~XalanEXSLTFunctionSin() 00936 { 00937 } 00938 00939 // These methods are inherited from Function ... 00940 00941 virtual XObjectPtr 00942 execute( 00943 XPathExecutionContext& executionContext, 00944 XalanNode* context, 00945 const XObjectArgVectorType& args, 00946 const LocatorType* locator) const; 00947 00948 #if !defined(XALAN_NO_USING_DECLARATION) 00949 using ParentType::execute; 00950 #endif 00951 00952 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00953 virtual Function* 00954 #else 00955 virtual XalanEXSLTFunctionSin* 00956 #endif 00957 clone() const 00958 { 00959 return new XalanEXSLTFunctionSin(*this); 00960 } 00961 00962 protected: 00963 00964 const XalanDOMString 00965 getError() const; 00966 00967 private: 00968 00969 // Not implemented... 00970 XalanEXSLTFunctionSin& 00971 operator=(const XalanEXSLTFunctionSin&); 00972 00973 bool 00974 operator==(const XalanEXSLTFunctionSin&) const; 00975 }; 00976 00977 00978 00979 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSqrt : public Function 00980 { 00981 public: 00982 00983 typedef Function ParentType; 00984 00985 XalanEXSLTFunctionSqrt() 00986 { 00987 } 00988 00989 virtual 00990 ~XalanEXSLTFunctionSqrt() 00991 { 00992 } 00993 00994 // These methods are inherited from Function ... 00995 00996 virtual XObjectPtr 00997 execute( 00998 XPathExecutionContext& executionContext, 00999 XalanNode* context, 01000 const XObjectArgVectorType& args, 01001 const LocatorType* locator) const; 01002 01003 #if !defined(XALAN_NO_USING_DECLARATION) 01004 using ParentType::execute; 01005 #endif 01006 01007 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 01008 virtual Function* 01009 #else 01010 virtual XalanEXSLTFunctionSqrt* 01011 #endif 01012 clone() const 01013 { 01014 return new XalanEXSLTFunctionSqrt(*this); 01015 } 01016 01017 protected: 01018 01019 const XalanDOMString 01020 getError() const; 01021 01022 private: 01023 01024 // Not implemented... 01025 XalanEXSLTFunctionSqrt& 01026 operator=(const XalanEXSLTFunctionSqrt&); 01027 01028 bool 01029 operator==(const XalanEXSLTFunctionSqrt&) const; 01030 }; 01031 01032 01033 01034 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTan : public Function 01035 { 01036 public: 01037 01038 typedef Function ParentType; 01039 01040 XalanEXSLTFunctionTan() 01041 { 01042 } 01043 01044 virtual 01045 ~XalanEXSLTFunctionTan() 01046 { 01047 } 01048 01049 // These methods are inherited from Function ... 01050 01051 virtual XObjectPtr 01052 execute( 01053 XPathExecutionContext& executionContext, 01054 XalanNode* context, 01055 const XObjectArgVectorType& args, 01056 const LocatorType* locator) const; 01057 01058 #if !defined(XALAN_NO_USING_DECLARATION) 01059 using ParentType::execute; 01060 #endif 01061 01062 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 01063 virtual Function* 01064 #else 01065 virtual XalanEXSLTFunctionTan* 01066 #endif 01067 clone() const 01068 { 01069 return new XalanEXSLTFunctionTan(*this); 01070 } 01071 01072 protected: 01073 01074 const XalanDOMString 01075 getError() const; 01076 01077 private: 01078 01079 // Not implemented... 01080 XalanEXSLTFunctionTan& 01081 operator=(const XalanEXSLTFunctionTan&); 01082 01083 bool 01084 operator==(const XalanEXSLTFunctionTan&) const; 01085 }; 01086 01087 01088 01089 XALAN_CPP_NAMESPACE_END 01090 01091 01092 01093 #endif // EXSLT_MATHIMPL_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 |
|