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