## Xalan-C++ API Documentation

### The Xalan C++ XSLT Processor Version 1.10

Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members

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