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_STRINGIMPL_HEADER_GUARD_1357924680) 00058 #define EXSLT_STRINGIMPL_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 XalanEXSLTFunctionAlign : public Function 00071 { 00072 public: 00073 00074 XalanEXSLTFunctionAlign() 00075 { 00076 } 00077 00078 virtual 00079 ~XalanEXSLTFunctionAlign() 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 XalanEXSLTFunctionAlign* 00096 #endif 00097 clone() const 00098 { 00099 return new XalanEXSLTFunctionAlign(*this); 00100 } 00101 00102 protected: 00103 00104 const XalanDOMString 00105 getError() const 00106 { 00107 return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXLT function align() accepts two or three arguments")); 00108 } 00109 00110 private: 00111 00112 // Not implemented... 00113 XalanEXSLTFunctionAlign& 00114 operator=(const XalanEXSLTFunctionAlign&); 00115 00116 bool 00117 operator==(const XalanEXSLTFunctionAlign&) const; 00118 00119 00120 // Data members... 00121 static const XalanDOMChar s_centerString[]; 00122 static const XalanDOMChar s_rightString[]; 00123 }; 00124 00125 00126 00127 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionConcat : public Function 00128 { 00129 public: 00130 00131 XalanEXSLTFunctionConcat() : 00132 Function() 00133 { 00134 } 00135 00136 virtual 00137 ~XalanEXSLTFunctionConcat() 00138 { 00139 } 00140 00141 // These methods are inherited from Function ... 00142 00143 virtual XObjectPtr 00144 execute( 00145 XPathExecutionContext& executionContext, 00146 XalanNode* context, 00147 const XObjectArgVectorType& args, 00148 const Locator* locator) const; 00149 00150 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00151 virtual Function* 00152 #else 00153 virtual XalanEXSLTFunctionConcat* 00154 #endif 00155 clone() const 00156 { 00157 return new XalanEXSLTFunctionConcat(*this); 00158 } 00159 00160 protected: 00161 00162 const XalanDOMString 00163 getError() const 00164 { 00165 return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXLT function concat() accepts one argument")); 00166 } 00167 00168 private: 00169 00170 // Not implemented... 00171 XalanEXSLTFunctionConcat& 00172 operator=(const XalanEXSLTFunctionConcat&); 00173 00174 bool 00175 operator==(const XalanEXSLTFunctionConcat&) const; 00176 }; 00177 00178 00179 00180 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionPadding : public Function 00181 { 00182 public: 00183 00184 XalanEXSLTFunctionPadding() : 00185 Function(), 00186 m_space(s_spaceString) 00187 { 00188 } 00189 00190 virtual 00191 ~XalanEXSLTFunctionPadding() 00192 { 00193 } 00194 00195 // These methods are inherited from Function ... 00196 00197 virtual XObjectPtr 00198 execute( 00199 XPathExecutionContext& executionContext, 00200 XalanNode* context, 00201 const XObjectArgVectorType& args, 00202 const Locator* locator) const; 00203 00204 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00205 virtual Function* 00206 #else 00207 virtual XalanEXSLTFunctionPadding* 00208 #endif 00209 clone() const 00210 { 00211 return new XalanEXSLTFunctionPadding(*this); 00212 } 00213 00214 protected: 00215 00216 const XalanDOMString 00217 getError() const 00218 { 00219 return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXLT function padding() accepts one or two arguments")); 00220 } 00221 00222 private: 00223 00224 // Not implemented... 00225 XalanEXSLTFunctionPadding& 00226 operator=(const XalanEXSLTFunctionPadding&); 00227 00228 bool 00229 operator==(const XalanEXSLTFunctionPadding&) const; 00230 00231 00232 // Data members... 00233 const XalanDOMString m_space; 00234 00235 static const XalanDOMChar s_spaceString[]; 00236 }; 00237 00238 00239 00240 #if 0 00241 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAsin : public Function 00242 { 00243 public: 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 Locator* locator) const; 00262 00263 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00264 virtual Function* 00265 #else 00266 virtual XalanEXSLTFunctionAsin* 00267 #endif 00268 clone() const 00269 { 00270 return new XalanEXSLTFunctionAsin(*this); 00271 } 00272 00273 protected: 00274 00275 const XalanDOMString 00276 getError() const; 00277 00278 private: 00279 00280 // Not implemented... 00281 XalanEXSLTFunctionAsin& 00282 operator=(const XalanEXSLTFunctionAsin&); 00283 00284 bool 00285 operator==(const XalanEXSLTFunctionAsin&) const; 00286 00287 00288 // Data members... 00289 static const XalanDOMString s_emptyString; 00290 }; 00291 00292 00293 00294 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAtan : public Function 00295 { 00296 public: 00297 00298 XalanEXSLTFunctionAtan() 00299 { 00300 } 00301 00302 virtual 00303 ~XalanEXSLTFunctionAtan() 00304 { 00305 } 00306 00307 // These methods are inherited from Function ... 00308 00309 virtual XObjectPtr 00310 execute( 00311 XPathExecutionContext& executionContext, 00312 XalanNode* context, 00313 const XObjectArgVectorType& args, 00314 const Locator* locator) const; 00315 00316 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00317 virtual Function* 00318 #else 00319 virtual XalanEXSLTFunctionAtan* 00320 #endif 00321 clone() const 00322 { 00323 return new XalanEXSLTFunctionAtan(*this); 00324 } 00325 00326 protected: 00327 00328 const XalanDOMString 00329 getError() const; 00330 00331 private: 00332 00333 // Not implemented... 00334 XalanEXSLTFunctionAtan& 00335 operator=(const XalanEXSLTFunctionAtan&); 00336 00337 bool 00338 operator==(const XalanEXSLTFunctionAtan&) const; 00339 }; 00340 00341 00342 00343 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionAtan2 : public Function 00344 { 00345 public: 00346 00347 XalanEXSLTFunctionAtan2() 00348 { 00349 } 00350 00351 virtual 00352 ~XalanEXSLTFunctionAtan2() 00353 { 00354 } 00355 00356 // These methods are inherited from Function ... 00357 00358 virtual XObjectPtr 00359 execute( 00360 XPathExecutionContext& executionContext, 00361 XalanNode* context, 00362 const XObjectArgVectorType& args, 00363 const Locator* locator) const; 00364 00365 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00366 virtual Function* 00367 #else 00368 virtual XalanEXSLTFunctionAtan2* 00369 #endif 00370 clone() const 00371 { 00372 return new XalanEXSLTFunctionAtan2(*this); 00373 } 00374 00375 protected: 00376 00377 const XalanDOMString 00378 getError() const; 00379 00380 private: 00381 00382 // Not implemented... 00383 XalanEXSLTFunctionAtan2& 00384 operator=(const XalanEXSLTFunctionAtan2&); 00385 00386 bool 00387 operator==(const XalanEXSLTFunctionAtan2&) const; 00388 }; 00389 00390 00391 00392 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionConstant : public Function 00393 { 00394 public: 00395 00396 XalanEXSLTFunctionConstant() 00397 { 00398 } 00399 00400 virtual 00401 ~XalanEXSLTFunctionConstant() 00402 { 00403 } 00404 00405 // These methods are inherited from Function ... 00406 00407 virtual XObjectPtr 00408 execute( 00409 XPathExecutionContext& executionContext, 00410 XalanNode* context, 00411 const XObjectArgVectorType& args, 00412 const Locator* locator) const; 00413 00414 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00415 virtual Function* 00416 #else 00417 virtual XalanEXSLTFunctionConstant* 00418 #endif 00419 clone() const 00420 { 00421 return new XalanEXSLTFunctionConstant(*this); 00422 } 00423 00424 protected: 00425 00426 const XalanDOMString 00427 getError() const 00428 { 00429 return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("The EXLT function constant() function accepts two arguments")); 00430 } 00431 00432 private: 00433 00434 static const XalanDOMChar s_eString[]; 00435 static const XalanDOMChar s_ln10String[]; 00436 static const XalanDOMChar s_ln2String[]; 00437 static const XalanDOMChar s_log2EString[]; 00438 static const XalanDOMChar s_piString[]; 00439 static const XalanDOMChar s_sqrt1_2String[]; 00440 static const XalanDOMChar s_sqrt2String[]; 00441 00442 static const char s_eValueString[]; 00443 static const char s_ln10ValueString[]; 00444 static const char s_ln2ValueString[]; 00445 static const char s_log2EValueString[]; 00446 static const char s_piValueString[]; 00447 static const char s_sqrt1_2ValueString[]; 00448 static const char s_sqrt2ValueString[]; 00449 00450 00451 // Not implemented... 00452 XalanEXSLTFunctionConstant& 00453 operator=(const XalanEXSLTFunctionConstant&); 00454 00455 bool 00456 operator==(const XalanEXSLTFunctionConstant&) const; 00457 }; 00458 00459 00460 00461 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionCos : public Function 00462 { 00463 public: 00464 00465 XalanEXSLTFunctionCos() 00466 { 00467 } 00468 00469 virtual 00470 ~XalanEXSLTFunctionCos() 00471 { 00472 } 00473 00474 // These methods are inherited from Function ... 00475 00476 virtual XObjectPtr 00477 execute( 00478 XPathExecutionContext& executionContext, 00479 XalanNode* context, 00480 const XObjectArgVectorType& args, 00481 const Locator* locator) const; 00482 00483 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00484 virtual Function* 00485 #else 00486 virtual XalanEXSLTFunctionCos* 00487 #endif 00488 clone() const 00489 { 00490 return new XalanEXSLTFunctionCos(*this); 00491 } 00492 00493 protected: 00494 00495 const XalanDOMString 00496 getError() const; 00497 00498 private: 00499 00500 // Not implemented... 00501 XalanEXSLTFunctionCos& 00502 operator=(const XalanEXSLTFunctionCos&); 00503 00504 bool 00505 operator==(const XalanEXSLTFunctionCos&) const; 00506 }; 00507 00508 00509 00510 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionExp : public Function 00511 { 00512 public: 00513 00514 XalanEXSLTFunctionExp() 00515 { 00516 } 00517 00518 virtual 00519 ~XalanEXSLTFunctionExp() 00520 { 00521 } 00522 00523 // These methods are inherited from Function ... 00524 00525 virtual XObjectPtr 00526 execute( 00527 XPathExecutionContext& executionContext, 00528 XalanNode* context, 00529 const XObjectArgVectorType& args, 00530 const Locator* locator) const; 00531 00532 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00533 virtual Function* 00534 #else 00535 virtual XalanEXSLTFunctionExp* 00536 #endif 00537 clone() const 00538 { 00539 return new XalanEXSLTFunctionExp(*this); 00540 } 00541 00542 protected: 00543 00544 const XalanDOMString 00545 getError() const; 00546 00547 private: 00548 00549 // Not implemented... 00550 XalanEXSLTFunctionExp& 00551 operator=(const XalanEXSLTFunctionExp&); 00552 00553 bool 00554 operator==(const XalanEXSLTFunctionExp&) const; 00555 }; 00556 00557 00558 00559 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHighest : public Function 00560 { 00561 public: 00562 00563 XalanEXSLTFunctionHighest() 00564 { 00565 } 00566 00567 virtual 00568 ~XalanEXSLTFunctionHighest() 00569 { 00570 } 00571 00572 // These methods are inherited from Function ... 00573 00574 virtual XObjectPtr 00575 execute( 00576 XPathExecutionContext& executionContext, 00577 XalanNode* context, 00578 const XObjectArgVectorType& args, 00579 const Locator* locator) const; 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 XalanEXSLTFunctionLog() 00613 { 00614 } 00615 00616 virtual 00617 ~XalanEXSLTFunctionLog() 00618 { 00619 } 00620 00621 // These methods are inherited from Function ... 00622 00623 virtual XObjectPtr 00624 execute( 00625 XPathExecutionContext& executionContext, 00626 XalanNode* context, 00627 const XObjectArgVectorType& args, 00628 const Locator* locator) const; 00629 00630 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00631 virtual Function* 00632 #else 00633 virtual XalanEXSLTFunctionLog* 00634 #endif 00635 clone() const 00636 { 00637 return new XalanEXSLTFunctionLog(*this); 00638 } 00639 00640 protected: 00641 00642 const XalanDOMString 00643 getError() const; 00644 00645 private: 00646 00647 // Not implemented... 00648 XalanEXSLTFunctionLog& 00649 operator=(const XalanEXSLTFunctionLog&); 00650 00651 bool 00652 operator==(const XalanEXSLTFunctionLog&) const; 00653 }; 00654 00655 00656 00657 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLowest : public Function 00658 { 00659 public: 00660 00661 XalanEXSLTFunctionLowest() 00662 { 00663 } 00664 00665 virtual 00666 ~XalanEXSLTFunctionLowest() 00667 { 00668 } 00669 00670 // These methods are inherited from Function ... 00671 00672 virtual XObjectPtr 00673 execute( 00674 XPathExecutionContext& executionContext, 00675 XalanNode* context, 00676 const XObjectArgVectorType& args, 00677 const Locator* locator) const; 00678 00679 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00680 virtual Function* 00681 #else 00682 virtual XalanEXSLTFunctionLowest* 00683 #endif 00684 clone() const 00685 { 00686 return new XalanEXSLTFunctionLowest(*this); 00687 } 00688 00689 protected: 00690 00691 const XalanDOMString 00692 getError() const; 00693 00694 private: 00695 00696 // Not implemented... 00697 XalanEXSLTFunctionLowest& 00698 operator=(const XalanEXSLTFunctionLowest&); 00699 00700 bool 00701 operator==(const XalanEXSLTFunctionLowest&) const; 00702 }; 00703 00704 00705 00706 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMax : public Function 00707 { 00708 public: 00709 00710 XalanEXSLTFunctionMax() 00711 { 00712 } 00713 00714 virtual 00715 ~XalanEXSLTFunctionMax() 00716 { 00717 } 00718 00719 // These methods are inherited from Function ... 00720 00721 virtual XObjectPtr 00722 execute( 00723 XPathExecutionContext& executionContext, 00724 XalanNode* context, 00725 const XObjectArgVectorType& args, 00726 const Locator* locator) const; 00727 00728 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00729 virtual Function* 00730 #else 00731 virtual XalanEXSLTFunctionMax* 00732 #endif 00733 clone() const 00734 { 00735 return new XalanEXSLTFunctionMax(*this); 00736 } 00737 00738 protected: 00739 00740 const XalanDOMString 00741 getError() const; 00742 00743 private: 00744 00745 // Not implemented... 00746 XalanEXSLTFunctionMax& 00747 operator=(const XalanEXSLTFunctionMax&); 00748 00749 bool 00750 operator==(const XalanEXSLTFunctionMax&) const; 00751 }; 00752 00753 00754 00755 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionMin : public Function 00756 { 00757 public: 00758 00759 XalanEXSLTFunctionMin() 00760 { 00761 } 00762 00763 virtual 00764 ~XalanEXSLTFunctionMin() 00765 { 00766 } 00767 00768 // These methods are inherited from Function ... 00769 00770 virtual XObjectPtr 00771 execute( 00772 XPathExecutionContext& executionContext, 00773 XalanNode* context, 00774 const XObjectArgVectorType& args, 00775 const Locator* locator) const; 00776 00777 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00778 virtual Function* 00779 #else 00780 virtual XalanEXSLTFunctionMin* 00781 #endif 00782 clone() const 00783 { 00784 return new XalanEXSLTFunctionMin(*this); 00785 } 00786 00787 protected: 00788 00789 const XalanDOMString 00790 getError() 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 XalanEXSLTFunctionPower() 00809 { 00810 } 00811 00812 virtual 00813 ~XalanEXSLTFunctionPower() 00814 { 00815 } 00816 00817 // These methods are inherited from Function ... 00818 00819 virtual XObjectPtr 00820 execute( 00821 XPathExecutionContext& executionContext, 00822 XalanNode* context, 00823 const XObjectArgVectorType& args, 00824 const Locator* locator) const; 00825 00826 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00827 virtual Function* 00828 #else 00829 virtual XalanEXSLTFunctionPower* 00830 #endif 00831 clone() const 00832 { 00833 return new XalanEXSLTFunctionPower(*this); 00834 } 00835 00836 protected: 00837 00838 const XalanDOMString 00839 getError() const; 00840 00841 private: 00842 00843 // Not implemented... 00844 XalanEXSLTFunctionPower& 00845 operator=(const XalanEXSLTFunctionPower&); 00846 00847 bool 00848 operator==(const XalanEXSLTFunctionPower&) const; 00849 }; 00850 00851 00852 00853 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSin : public Function 00854 { 00855 public: 00856 00857 XalanEXSLTFunctionSin() 00858 { 00859 } 00860 00861 virtual 00862 ~XalanEXSLTFunctionSin() 00863 { 00864 } 00865 00866 // These methods are inherited from Function ... 00867 00868 virtual XObjectPtr 00869 execute( 00870 XPathExecutionContext& executionContext, 00871 XalanNode* context, 00872 const XObjectArgVectorType& args, 00873 const Locator* locator) const; 00874 00875 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00876 virtual Function* 00877 #else 00878 virtual XalanEXSLTFunctionSin* 00879 #endif 00880 clone() const 00881 { 00882 return new XalanEXSLTFunctionSin(*this); 00883 } 00884 00885 protected: 00886 00887 const XalanDOMString 00888 getError() const; 00889 00890 private: 00891 00892 // Not implemented... 00893 XalanEXSLTFunctionSin& 00894 operator=(const XalanEXSLTFunctionSin&); 00895 00896 bool 00897 operator==(const XalanEXSLTFunctionSin&) const; 00898 }; 00899 00900 00901 00902 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionSqrt : public Function 00903 { 00904 public: 00905 00906 XalanEXSLTFunctionSqrt() 00907 { 00908 } 00909 00910 virtual 00911 ~XalanEXSLTFunctionSqrt() 00912 { 00913 } 00914 00915 // These methods are inherited from Function ... 00916 00917 virtual XObjectPtr 00918 execute( 00919 XPathExecutionContext& executionContext, 00920 XalanNode* context, 00921 const XObjectArgVectorType& args, 00922 const Locator* locator) const; 00923 00924 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00925 virtual Function* 00926 #else 00927 virtual XalanEXSLTFunctionSqrt* 00928 #endif 00929 clone() const 00930 { 00931 return new XalanEXSLTFunctionSqrt(*this); 00932 } 00933 00934 protected: 00935 00936 const XalanDOMString 00937 getError() const; 00938 00939 private: 00940 00941 // Not implemented... 00942 XalanEXSLTFunctionSqrt& 00943 operator=(const XalanEXSLTFunctionSqrt&); 00944 00945 bool 00946 operator==(const XalanEXSLTFunctionSqrt&) const; 00947 }; 00948 00949 00950 00951 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTan : public Function 00952 { 00953 public: 00954 00955 XalanEXSLTFunctionTan() 00956 { 00957 } 00958 00959 virtual 00960 ~XalanEXSLTFunctionTan() 00961 { 00962 } 00963 00964 // These methods are inherited from Function ... 00965 00966 virtual XObjectPtr 00967 execute( 00968 XPathExecutionContext& executionContext, 00969 XalanNode* context, 00970 const XObjectArgVectorType& args, 00971 const Locator* locator) const; 00972 00973 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00974 virtual Function* 00975 #else 00976 virtual XalanEXSLTFunctionTan* 00977 #endif 00978 clone() const 00979 { 00980 return new XalanEXSLTFunctionTan(*this); 00981 } 00982 00983 protected: 00984 00985 const XalanDOMString 00986 getError() const; 00987 00988 private: 00989 00990 // Not implemented... 00991 XalanEXSLTFunctionTan& 00992 operator=(const XalanEXSLTFunctionTan&); 00993 00994 bool 00995 operator==(const XalanEXSLTFunctionTan&) const; 00996 }; 00997 #endif 00998 00999 01000 #endif // EXSLT_STRINGIMPL_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 |
|