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  

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