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