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.