Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

Main Page | Directories | 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.