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