## Xalan-C++ API Documentation

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

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