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