## Xalan-C++ API Documentation

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

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