Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

XalanEXSLTMathImpl.hpp

Go to the documentation of this file.
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() const 00071 { 00072 return new XalanEXSLTFunctionAbs(*this); 00073 } 00074 00075 protected: 00076 00077 const XalanDOMString 00078 getError() 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() const 00126 { 00127 return new XalanEXSLTFunctionRandom(*this); 00128 } 00129 00130 protected: 00131 00132 const XalanDOMString 00133 getError() 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() const 00181 { 00182 return new XalanEXSLTFunctionAcos(*this); 00183 } 00184 00185 protected: 00186 00187 const XalanDOMString 00188 getError() 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() const 00236 { 00237 return new XalanEXSLTFunctionAsin(*this); 00238 } 00239 00240 protected: 00241 00242 const XalanDOMString 00243 getError() 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() const 00291 { 00292 return new XalanEXSLTFunctionAtan(*this); 00293 } 00294 00295 protected: 00296 00297 const XalanDOMString 00298 getError() 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() const 00346 { 00347 return new XalanEXSLTFunctionAtan2(*this); 00348 } 00349 00350 protected: 00351 00352 const XalanDOMString 00353 getError() 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() const 00401 { 00402 return new XalanEXSLTFunctionConstant(*this); 00403 } 00404 00405 protected: 00406 00407 const XalanDOMString 00408 getError() const 00409 { 00410 return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"constant()"); 00411 00412 } 00413 00414 private: 00415 00416 static const XalanDOMChar s_eString[]; 00417 static const XalanDOMChar s_ln10String[]; 00418 static const XalanDOMChar s_ln2String[]; 00419 static const XalanDOMChar s_log2EString[]; 00420 static const XalanDOMChar s_piString[]; 00421 static const XalanDOMChar s_sqrt1_2String[]; 00422 static const XalanDOMChar s_sqrt2String[]; 00423 00424 static const double s_eValues[]; 00425 static const double s_ln10Values[]; 00426 static const double s_ln2Values[]; 00427 static const double s_log2EValues[]; 00428 static const double s_piValues[]; 00429 static const double s_sqrt1_2Values[]; 00430 static const double s_sqrt2Values[]; 00431 00432 00433 // Not implemented... 00434 XalanEXSLTFunctionConstant& 00435 operator=(const XalanEXSLTFunctionConstant&); 00436 00437 bool 00438 operator==(const XalanEXSLTFunctionConstant&) const; 00439 }; 00440 00441 00442 00443 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionCos : public Function 00444 { 00445 public: 00446 00447 typedef Function ParentType; 00448 00449 XalanEXSLTFunctionCos() 00450 { 00451 } 00452 00453 virtual 00454 ~XalanEXSLTFunctionCos() 00455 { 00456 } 00457 00458 // These methods are inherited from Function ... 00459 00460 virtual XObjectPtr 00461 execute( 00462 XPathExecutionContext& executionContext, 00463 XalanNode* context, 00464 const XObjectArgVectorType& args, 00465 const LocatorType* locator) const; 00466 00467 #if !defined(XALAN_NO_USING_DECLARATION) 00468 using ParentType::execute; 00469 #endif 00470 00471 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00472 virtual Function* 00473 #else 00474 virtual XalanEXSLTFunctionCos* 00475 #endif 00476 clone() const 00477 { 00478 return new XalanEXSLTFunctionCos(*this); 00479 } 00480 00481 protected: 00482 00483 const XalanDOMString 00484 getError() const; 00485 00486 private: 00487 00488 // Not implemented... 00489 XalanEXSLTFunctionCos& 00490 operator=(const XalanEXSLTFunctionCos&); 00491 00492 bool 00493 operator==(const XalanEXSLTFunctionCos&) const; 00494 }; 00495 00496 00497 00498 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionExp : public Function 00499 { 00500 public: 00501 00502 typedef Function ParentType; 00503 00504 XalanEXSLTFunctionExp() 00505 { 00506 } 00507 00508 virtual 00509 ~XalanEXSLTFunctionExp() 00510 { 00511 } 00512 00513 // These methods are inherited from Function ... 00514 00515 virtual XObjectPtr 00516 execute( 00517 XPathExecutionContext& executionContext, 00518 XalanNode* context, 00519 const XObjectArgVectorType& args, 00520 const LocatorType* locator) const; 00521 00522 #if !defined(XALAN_NO_USING_DECLARATION) 00523 using ParentType::execute; 00524 #endif 00525 00526 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00527 virtual Function* 00528 #else 00529 virtual XalanEXSLTFunctionExp* 00530 #endif 00531 clone() const 00532 { 00533 return new XalanEXSLTFunctionExp(*this); 00534 } 00535 00536 protected: 00537 00538 const XalanDOMString 00539 getError() const; 00540 00541 private: 00542 00543 // Not implemented... 00544 XalanEXSLTFunctionExp& 00545 operator=(const XalanEXSLTFunctionExp&); 00546 00547 bool 00548 operator==(const XalanEXSLTFunctionExp&) const; 00549 }; 00550 00551 00552 00553 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHighest : public Function 00554 { 00555 public: 00556 00557 typedef Function ParentType; 00558 00559 XalanEXSLTFunctionHighest() 00560 { 00561 } 00562 00563 virtual 00564 ~XalanEXSLTFunctionHighest() 00565 { 00566 } 00567 00568 // These methods are inherited from Function ... 00569 00570 virtual XObjectPtr 00571 execute( 00572 XPathExecutionContext& executionContext, 00573 XalanNode* context, 00574 const XObjectArgVectorType& args, 00575 const LocatorType* locator) const; 00576 00577 #if !defined(XALAN_NO_USING_DECLARATION) 00578 using ParentType::execute; 00579 #endif 00580 00581 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00582 virtual Function* 00583 #else 00584 virtual XalanEXSLTFunctionHighest* 00585 #endif 00586 clone() const 00587 { 00588 return new XalanEXSLTFunctionHighest(*this); 00589 } 00590 00591 protected: 00592 00593 const XalanDOMString 00594 getError() const; 00595 00596 private: 00597 00598 // Not implemented... 00599 XalanEXSLTFunctionHighest& 00600 operator=(const XalanEXSLTFunctionHighest&); 00601 00602 bool 00603 operator==(const XalanEXSLTFunctionHighest&) const; 00604 }; 00605 00606 00607 00608 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLog : public Function 00609 { 00610 public: 00611 00612 typedef Function ParentType; 00613 00614 XalanEXSLTFunctionLog() 00615 { 00616 } 00617 00618 virtual 00619 ~XalanEXSLTFunctionLog() 00620 { 00621 } 00622 00623 // These methods are inherited from Function ... 00624 00625 virtual XObjectPtr 00626 execute( 00627 XPathExecutionContext& executionContext, 00628 XalanNode* context, 00629 const XObjectArgVectorType& args, 00630 const LocatorType* locator) const; 00631 00632 #if !defined(XALAN_NO_USING_DECLARATION) 00633 using ParentType::execute; 00634 #endif 00635 00636 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00637 virtual Function* 00638 #else 00639 virtual XalanEXSLTFunctionLog* 00640 #endif 00641 clone() const 00642 { 00643 return new XalanEXSLTFunctionLog(*this); 00644 } 00645 00646 protected: 00647 00648 const XalanDOMString 00649 getError() const; 00650 00651 private: 00652 00653 // Not implemented... 00654 XalanEXSLTFunctionLog& 00655 operator=(const XalanEXSLTFunctionLog&); 00656 00657 bool 00658 operator==(const XalanEXSLTFunctionLog&) const; 00659 }; 00660 00661 00662 00663 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLowest : public Function 00664 { 00665 public: 00666 00667 typedef Function ParentType; 00668 00669 XalanEXSLTFunctionLowest() 00670 { 00671 } 00672 00673 virtual 00674 ~XalanEXSLTFunctionLowest() 00675 { 00676 } 00677 00678 // These methods are inherited from Function ... 00679 00680 virtual XObjectPtr 00681 execute( 00682 XPathExecutionContext& executionContext, 00683 XalanNode* context, 00684 const XObjectArgVectorType& args, 00685 const LocatorType* locator) const; 00686 00687 #if !defined(XALAN_NO_USING_DECLARATION) 00688 using ParentType::execute; 00689 #endif 00690 00691 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00692 virtual Function* 00693 #else 00694 virtual XalanEXSLTFunctionLowest* 00695 #endif 00696 clone() const 00697 { 00698 return new XalanEXSLTFunctionLowest(*this); 00699 } 00700 00701 protected: 00702 00703 const XalanDOMString 00704 getError() const; 00705 00706 private: 00707 00708 // Not implemented... 00709 XalanEXSLTFunctionLowest& 00710 operator=(const XalanEXSLTFunctionLowest&); 00711 00712 bool 00713 operator==(const XalanEXSLTFunctionLowest&) const; 00714 }; 00715 00716 00717 00718 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMax : public Function 00719 { 00720 public: 00721 00722 typedef Function ParentType; 00723 00724 XalanEXSLTFunctionMax() 00725 { 00726 } 00727 00728 virtual 00729 ~XalanEXSLTFunctionMax() 00730 { 00731 } 00732 00733 // These methods are inherited from Function ... 00734 00735 virtual XObjectPtr 00736 execute( 00737 XPathExecutionContext& executionContext, 00738 XalanNode* context, 00739 const XObjectArgVectorType& args, 00740 const LocatorType* locator) const; 00741 00742 #if !defined(XALAN_NO_USING_DECLARATION) 00743 using ParentType::execute; 00744 #endif 00745 00746 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00747 virtual Function* 00748 #else 00749 virtual XalanEXSLTFunctionMax* 00750 #endif 00751 clone() const 00752 { 00753 return new XalanEXSLTFunctionMax(*this); 00754 } 00755 00756 protected: 00757 00758 const XalanDOMString 00759 getError() const; 00760 00761 private: 00762 00763 // Not implemented... 00764 XalanEXSLTFunctionMax& 00765 operator=(const XalanEXSLTFunctionMax&); 00766 00767 bool 00768 operator==(const XalanEXSLTFunctionMax&) const; 00769 }; 00770 00771 00772 00773 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMin : public Function 00774 { 00775 public: 00776 00777 typedef Function ParentType; 00778 00779 XalanEXSLTFunctionMin() 00780 { 00781 } 00782 00783 virtual 00784 ~XalanEXSLTFunctionMin() 00785 { 00786 } 00787 00788 // These methods are inherited from Function ... 00789 00790 virtual XObjectPtr 00791 execute( 00792 XPathExecutionContext& executionContext, 00793 XalanNode* context, 00794 const XObjectArgVectorType& args, 00795 const LocatorType* locator) const; 00796 00797 #if !defined(XALAN_NO_USING_DECLARATION) 00798 using ParentType::execute; 00799 #endif 00800 00801 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00802 virtual Function* 00803 #else 00804 virtual XalanEXSLTFunctionMin* 00805 #endif 00806 clone() const 00807 { 00808 return new XalanEXSLTFunctionMin(*this); 00809 } 00810 00811 protected: 00812 00813 const XalanDOMString 00814 getError() const; 00815 00816 private: 00817 00818 // Not implemented... 00819 XalanEXSLTFunctionMin& 00820 operator=(const XalanEXSLTFunctionMin&); 00821 00822 bool 00823 operator==(const XalanEXSLTFunctionMin&) const; 00824 }; 00825 00826 00827 00828 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionPower : public Function 00829 { 00830 public: 00831 00832 typedef Function ParentType; 00833 00834 XalanEXSLTFunctionPower() 00835 { 00836 } 00837 00838 virtual 00839 ~XalanEXSLTFunctionPower() 00840 { 00841 } 00842 00843 // These methods are inherited from Function ... 00844 00845 virtual XObjectPtr 00846 execute( 00847 XPathExecutionContext& executionContext, 00848 XalanNode* context, 00849 const XObjectArgVectorType& args, 00850 const LocatorType* locator) const; 00851 00852 #if !defined(XALAN_NO_USING_DECLARATION) 00853 using ParentType::execute; 00854 #endif 00855 00856 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00857 virtual Function* 00858 #else 00859 virtual XalanEXSLTFunctionPower* 00860 #endif 00861 clone() const 00862 { 00863 return new XalanEXSLTFunctionPower(*this); 00864 } 00865 00866 protected: 00867 00868 const XalanDOMString 00869 getError() const; 00870 00871 private: 00872 00873 // Not implemented... 00874 XalanEXSLTFunctionPower& 00875 operator=(const XalanEXSLTFunctionPower&); 00876 00877 bool 00878 operator==(const XalanEXSLTFunctionPower&) const; 00879 }; 00880 00881 00882 00883 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSin : public Function 00884 { 00885 public: 00886 00887 typedef Function ParentType; 00888 00889 XalanEXSLTFunctionSin() 00890 { 00891 } 00892 00893 virtual 00894 ~XalanEXSLTFunctionSin() 00895 { 00896 } 00897 00898 // These methods are inherited from Function ... 00899 00900 virtual XObjectPtr 00901 execute( 00902 XPathExecutionContext& executionContext, 00903 XalanNode* context, 00904 const XObjectArgVectorType& args, 00905 const LocatorType* locator) const; 00906 00907 #if !defined(XALAN_NO_USING_DECLARATION) 00908 using ParentType::execute; 00909 #endif 00910 00911 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00912 virtual Function* 00913 #else 00914 virtual XalanEXSLTFunctionSin* 00915 #endif 00916 clone() const 00917 { 00918 return new XalanEXSLTFunctionSin(*this); 00919 } 00920 00921 protected: 00922 00923 const XalanDOMString 00924 getError() const; 00925 00926 private: 00927 00928 // Not implemented... 00929 XalanEXSLTFunctionSin& 00930 operator=(const XalanEXSLTFunctionSin&); 00931 00932 bool 00933 operator==(const XalanEXSLTFunctionSin&) const; 00934 }; 00935 00936 00937 00938 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSqrt : public Function 00939 { 00940 public: 00941 00942 typedef Function ParentType; 00943 00944 XalanEXSLTFunctionSqrt() 00945 { 00946 } 00947 00948 virtual 00949 ~XalanEXSLTFunctionSqrt() 00950 { 00951 } 00952 00953 // These methods are inherited from Function ... 00954 00955 virtual XObjectPtr 00956 execute( 00957 XPathExecutionContext& executionContext, 00958 XalanNode* context, 00959 const XObjectArgVectorType& args, 00960 const LocatorType* locator) const; 00961 00962 #if !defined(XALAN_NO_USING_DECLARATION) 00963 using ParentType::execute; 00964 #endif 00965 00966 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00967 virtual Function* 00968 #else 00969 virtual XalanEXSLTFunctionSqrt* 00970 #endif 00971 clone() const 00972 { 00973 return new XalanEXSLTFunctionSqrt(*this); 00974 } 00975 00976 protected: 00977 00978 const XalanDOMString 00979 getError() const; 00980 00981 private: 00982 00983 // Not implemented... 00984 XalanEXSLTFunctionSqrt& 00985 operator=(const XalanEXSLTFunctionSqrt&); 00986 00987 bool 00988 operator==(const XalanEXSLTFunctionSqrt&) const; 00989 }; 00990 00991 00992 00993 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTan : public Function 00994 { 00995 public: 00996 00997 typedef Function ParentType; 00998 00999 XalanEXSLTFunctionTan() 01000 { 01001 } 01002 01003 virtual 01004 ~XalanEXSLTFunctionTan() 01005 { 01006 } 01007 01008 // These methods are inherited from Function ... 01009 01010 virtual XObjectPtr 01011 execute( 01012 XPathExecutionContext& executionContext, 01013 XalanNode* context, 01014 const XObjectArgVectorType& args, 01015 const LocatorType* locator) const; 01016 01017 #if !defined(XALAN_NO_USING_DECLARATION) 01018 using ParentType::execute; 01019 #endif 01020 01021 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 01022 virtual Function* 01023 #else 01024 virtual XalanEXSLTFunctionTan* 01025 #endif 01026 clone() const 01027 { 01028 return new XalanEXSLTFunctionTan(*this); 01029 } 01030 01031 protected: 01032 01033 const XalanDOMString 01034 getError() const; 01035 01036 private: 01037 01038 // Not implemented... 01039 XalanEXSLTFunctionTan& 01040 operator=(const XalanEXSLTFunctionTan&); 01041 01042 bool 01043 operator==(const XalanEXSLTFunctionTan&) const; 01044 }; 01045 01046 01047 01048 XALAN_CPP_NAMESPACE_END 01049 01050 01051 01052 #endif // EXSLT_MATHIMPL_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.8
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.