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.

dot

Xalan-C++ XSLT Processor Version 1.10
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.

Apache Logo