## Xalan-C++ API Documentation

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

Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members

# 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                     theBuffer,
    00074                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    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                     theBuffer ,
    00121                     XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
    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                     theBuffer,
    00184                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    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                     theBuffer,
    00233                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00234                     "distinct()");
    00235     }
    00236
    00237 private:
    00238
    00239     // Not implemented...
    00240     XalanEXSLTFunctionIntersection&
    00241     operator=(const XalanEXSLTFunctionIntersection&);
    00242
    00243     bool
    00244     operator==(const XalanEXSLTFunctionIntersection&) const;
    00245 };
    00246
    00247
    00248
    00249 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLeading : public Function
    00250 {
    00251 public:
    00252
    00253     typedef Function    ParentType;
    00254
    00255     XalanEXSLTFunctionLeading() :
    00256         Function()
    00257     {
    00258     }
    00259
    00260     virtual
    00261     ~XalanEXSLTFunctionLeading()
    00262     {
    00263     }
    00264
    00265     // These methods are inherited from Function ...
    00266
    00267     virtual XObjectPtr
    00268     execute(
    00269             XPathExecutionContext&          executionContext,
    00270             XalanNode*                      context,
    00271             const XObjectArgVectorType&     args,
    00272             const LocatorType*              locator) const;
    00273
    00274 #if !defined(XALAN_NO_USING_DECLARATION)
    00275     using ParentType::execute;
    00276 #endif
    00277
    00278 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00279     virtual Function*
    00280 #else
    00281     virtual XalanEXSLTFunctionLeading*
    00282 #endif
    00283     clone(MemoryManagerType&    theManager) const
    00284     {
    00285         return XalanCopyConstruct(theManager, *this);
    00286     }
    00287
    00288 protected:
    00289
    00290     virtual const XalanDOMString&
    00291     getError(XalanDOMString&    theBuffer) const
    00292     {
    00293         return XalanMessageLoader::getMessage(
    00294                     theBuffer,
    00295                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00296                     "leading()");
    00297     }
    00298
    00299 private:
    00300
    00301     // Not implemented...
    00302     XalanEXSLTFunctionLeading&
    00303     operator=(const XalanEXSLTFunctionLeading&);
    00304
    00305     bool
    00306     operator==(const XalanEXSLTFunctionLeading&) const;
    00307 };
    00308
    00309
    00310
    00311 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTrailing : public Function
    00312 {
    00313 public:
    00314
    00315     typedef Function    ParentType;
    00316
    00317     XalanEXSLTFunctionTrailing() :
    00318         Function()
    00319     {
    00320     }
    00321
    00322     virtual
    00323     ~XalanEXSLTFunctionTrailing()
    00324     {
    00325     }
    00326
    00327     // These methods are inherited from Function ...
    00328
    00329     virtual XObjectPtr
    00330     execute(
    00331             XPathExecutionContext&          executionContext,
    00332             XalanNode*                      context,
    00333             const XObjectArgVectorType&     args,
    00334             const LocatorType*              locator) const;
    00335
    00336 #if !defined(XALAN_NO_USING_DECLARATION)
    00337     using ParentType::execute;
    00338 #endif
    00339
    00340 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00341     virtual Function*
    00342 #else
    00343     virtual XalanEXSLTFunctionTrailing*
    00344 #endif
    00345     clone(MemoryManagerType&    theManager) const
    00346     {
    00347         return XalanCopyConstruct(theManager, *this);
    00348     }
    00349
    00350 protected:
    00351
    00352     virtual const XalanDOMString&
    00353     getError(XalanDOMString&    theBuffer) const
    00354     {
    00355         return XalanMessageLoader::getMessage(
    00356                     theBuffer,
    00357                     XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
    00358                     "trailing()");
    00359     }
    00360
    00361 private:
    00362
    00363     // Not implemented...
    00364     XalanEXSLTFunctionTrailing&
    00365     operator=(const XalanEXSLTFunctionTrailing&);
    00366
    00367     bool
    00368     operator==(const XalanEXSLTFunctionTrailing&) const;
    00369 };
    00370
    00371
    00372
    00373 XALAN_CPP_NAMESPACE_END
    00374
    00375
    00376
    00377 #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.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.