Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.4

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