## Xalan-C++ API Documentation

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

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

# XalanEXSLTSetImpl.hpp

Go to the documentation of this file.

    00001 /*
    00002  * Copyright 1999-2004 The Apache Software Foundation.
    00003  *
    00004  * Licensed under the Apache License, Version 2.0 (the "License");
    00005  * you may not use this file except in compliance with the License.
    00006  * You may obtain a copy of the License at
    00007  *
    00008  *     http://www.apache.org/licenses/LICENSE-2.0
    00009  *
    00010  * Unless required by applicable law or agreed to in writing, software
    00011  * distributed under the License is distributed on an "AS IS" BASIS,
    00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00013  * See the License for the specific language governing permissions and
    00014  * limitations under the License.
    00015  */
    00016 #if !defined(EXSLT_SETIMPL_HEADER_GUARD_1357924680)
    00017 #define EXSLT_SETIMPL_HEADER_GUARD_1357924680
    00018
    00019
    00020
    00021 #include "XalanEXSLTDefinitions.hpp"
    00022
    00023
    00024
    00025 #include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
    00026
    00027
    00028
    00029 #include <xalanc/XPath/Function.hpp>
    00030
    00031
    00032
    00033 #include <xalanc/XalanExtensions/FunctionDifference.hpp>
    00034 #include <xalanc/XalanExtensions/FunctionDistinct.hpp>
    00035 #include <xalanc/XalanExtensions/FunctionIntersection.hpp>
    00036
    00037
    00038
    00039 XALAN_CPP_NAMESPACE_BEGIN
    00040
    00041
    00042
    00043 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDifference : public FunctionDifference
    00044 {
    00045 public:
    00046
    00047     XalanEXSLTFunctionDifference() :
    00048         FunctionDifference()
    00049     {
    00050     }
    00051
    00052     virtual
    00053     ~XalanEXSLTFunctionDifference()
    00054     {
    00055     }
    00056
    00057 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00058     virtual Function*
    00059 #else
    00060     virtual XalanEXSLTFunctionDifference*
    00061 #endif
    00062     clone(MemoryManagerType&    theManager) const
    00063     {
    00064         return XalanCopyConstruct(theManager, *this);
    00065     }
    00066
    00067 protected:
    00068
    00069     virtual const XalanDOMString&
    00070     getError(XalanDOMString& theBuffer) const
    00071     {
    00072         return XalanMessageLoader::getMessage(
    00073                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00074                     theBuffer ,
    00075                     "difference()");
    00076     }
    00077
    00078 private:
    00079
    00080     // Not implemented...
    00081     XalanEXSLTFunctionDifference&
    00082     operator=(const XalanEXSLTFunctionDifference&);
    00083
    00084     bool
    00085     operator==(const XalanEXSLTFunctionDifference&) const;
    00086 };
    00087
    00088
    00089
    00090 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDistinct : public FunctionDistinct
    00091 {
    00092 public:
    00093
    00094     XalanEXSLTFunctionDistinct() :
    00095         FunctionDistinct()
    00096     {
    00097     }
    00098
    00099     virtual
    00100     ~XalanEXSLTFunctionDistinct()
    00101     {
    00102     }
    00103
    00104 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00105     virtual Function*
    00106 #else
    00107     virtual XalanEXSLTFunctionDistinct*
    00108 #endif
    00109     clone(MemoryManagerType&    theManager) const
    00110     {
    00111         return XalanCopyConstruct(theManager, *this);
    00112     }
    00113
    00114 protected:
    00115
    00116     virtual const XalanDOMString&
    00117     getError(XalanDOMString&    theBuffer) const
    00118     {
    00119         return XalanMessageLoader::getMessage(
    00120                     XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
    00121                     theBuffer ,
    00122                     "distinct()");
    00123     }
    00124
    00125
    00126 private:
    00127
    00128     // Not implemented...
    00129     XalanEXSLTFunctionDistinct&
    00130     operator=(const XalanEXSLTFunctionDistinct&);
    00131
    00132     bool
    00133     operator==(const XalanEXSLTFunctionDistinct&) const;
    00134 };
    00135
    00136
    00137
    00138 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHasSameNode : public Function
    00139 {
    00140 public:
    00141
    00142     typedef Function    ParentType;
    00143
    00144     XalanEXSLTFunctionHasSameNode() :
    00145         Function()
    00146     {
    00147     }
    00148
    00149     virtual
    00150     ~XalanEXSLTFunctionHasSameNode()
    00151     {
    00152     }
    00153
    00154     // These methods are inherited from Function ...
    00155
    00156     virtual XObjectPtr
    00157     execute(
    00158             XPathExecutionContext&          executionContext,
    00159             XalanNode*                      context,
    00160             const XObjectArgVectorType&     args,
    00161             const LocatorType*              locator) const;
    00162
    00163 #if !defined(XALAN_NO_USING_DECLARATION)
    00164     using ParentType::execute;
    00165 #endif
    00166
    00167 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00168     virtual Function*
    00169 #else
    00170     virtual XalanEXSLTFunctionHasSameNode*
    00171 #endif
    00172     clone(MemoryManagerType&    theManager) const
    00173     {
    00174         return XalanCopyConstruct(theManager, *this);
    00175     }
    00176
    00177 protected:
    00178
    00179     virtual const XalanDOMString&
    00180     getError(XalanDOMString&    theBuffer) const
    00181     {
    00182         return XalanMessageLoader::getMessage(
    00183                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00184                     theBuffer,
    00185                     "has-same-node()");
    00186     }
    00187
    00188
    00189
    00190 private:
    00191
    00192     // Not implemented...
    00193     XalanEXSLTFunctionHasSameNode&
    00194     operator=(const XalanEXSLTFunctionHasSameNode&);
    00195
    00196     bool
    00197     operator==(const XalanEXSLTFunctionHasSameNode&) const;
    00198 };
    00199
    00200
    00201
    00202 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionIntersection : public FunctionIntersection
    00203 {
    00204 public:
    00205
    00206     XalanEXSLTFunctionIntersection() :
    00207         FunctionIntersection()
    00208     {
    00209     }
    00210
    00211     virtual
    00212     ~XalanEXSLTFunctionIntersection()
    00213     {
    00214     }
    00215
    00216 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00217     virtual Function*
    00218 #else
    00219     virtual XalanEXSLTFunctionIntersection*
    00220 #endif
    00221     clone(MemoryManagerType&    theManager) const
    00222     {
    00223         return XalanCopyConstruct(theManager, *this);
    00224     }
    00225
    00226 protected:
    00227
    00228     virtual const XalanDOMString&
    00229     getError(XalanDOMString&    theBuffer) const
    00230     {
    00231         return XalanMessageLoader::getMessage(
    00232                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00233                     theBuffer,
    00234                     "distinct()");
    00235
    00236         return theBuffer;
    00237     }
    00238
    00239 private:
    00240
    00241     // Not implemented...
    00242     XalanEXSLTFunctionIntersection&
    00243     operator=(const XalanEXSLTFunctionIntersection&);
    00244
    00245     bool
    00246     operator==(const XalanEXSLTFunctionIntersection&) const;
    00247 };
    00248
    00249
    00250
    00251 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLeading : public Function
    00252 {
    00253 public:
    00254
    00255     typedef Function    ParentType;
    00256
    00257     XalanEXSLTFunctionLeading() :
    00258         Function()
    00259     {
    00260     }
    00261
    00262     virtual
    00263     ~XalanEXSLTFunctionLeading()
    00264     {
    00265     }
    00266
    00267     // These methods are inherited from Function ...
    00268
    00269     virtual XObjectPtr
    00270     execute(
    00271             XPathExecutionContext&          executionContext,
    00272             XalanNode*                      context,
    00273             const XObjectArgVectorType&     args,
    00274             const LocatorType*              locator) const;
    00275
    00276 #if !defined(XALAN_NO_USING_DECLARATION)
    00277     using ParentType::execute;
    00278 #endif
    00279
    00280 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00281     virtual Function*
    00282 #else
    00283     virtual XalanEXSLTFunctionLeading*
    00284 #endif
    00285     clone(MemoryManagerType&    theManager) const
    00286     {
    00287         return XalanCopyConstruct(theManager, *this);
    00288     }
    00289
    00290 protected:
    00291
    00292     virtual const XalanDOMString&
    00293     getError(XalanDOMString&    theBuffer) const
    00294     {
    00295         return XalanMessageLoader::getMessage(
    00296                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00297                     theBuffer,
    00298                     "leading()");
    00299
    00300         return theBuffer;
    00301     }
    00302
    00303 private:
    00304
    00305     // Not implemented...
    00306     XalanEXSLTFunctionLeading&
    00307     operator=(const XalanEXSLTFunctionLeading&);
    00308
    00309     bool
    00310     operator==(const XalanEXSLTFunctionLeading&) const;
    00311 };
    00312
    00313
    00314
    00315 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTrailing : public Function
    00316 {
    00317 public:
    00318
    00319     typedef Function    ParentType;
    00320
    00321     XalanEXSLTFunctionTrailing() :
    00322         Function()
    00323     {
    00324     }
    00325
    00326     virtual
    00327     ~XalanEXSLTFunctionTrailing()
    00328     {
    00329     }
    00330
    00331     // These methods are inherited from Function ...
    00332
    00333     virtual XObjectPtr
    00334     execute(
    00335             XPathExecutionContext&          executionContext,
    00336             XalanNode*                      context,
    00337             const XObjectArgVectorType&     args,
    00338             const LocatorType*              locator) const;
    00339
    00340 #if !defined(XALAN_NO_USING_DECLARATION)
    00341     using ParentType::execute;
    00342 #endif
    00343
    00344 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00345     virtual Function*
    00346 #else
    00347     virtual XalanEXSLTFunctionTrailing*
    00348 #endif
    00349     clone(MemoryManagerType&    theManager) const
    00350     {
    00351         return XalanCopyConstruct(theManager, *this);
    00352     }
    00353
    00354 protected:
    00355
    00356     virtual const XalanDOMString&
    00357     getError(XalanDOMString&    theBuffer) const
    00358     {
    00359         return XalanMessageLoader::getMessage(
    00360                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00361                     theBuffer,
    00362                     "trailing()");
    00363     }
    00364
    00365 private:
    00366
    00367     // Not implemented...
    00368     XalanEXSLTFunctionTrailing&
    00369     operator=(const XalanEXSLTFunctionTrailing&);
    00370
    00371     bool
    00372     operator==(const XalanEXSLTFunctionTrailing&) const;
    00373 };
    00374
    00375
    00376
    00377 XALAN_CPP_NAMESPACE_END
    00378
    00379
    00380
    00381 #endif  // EXSLT_SETIMPL_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.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.