Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.8

Main Page | Directories | 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() const
00063     {
00064         return new XalanEXSLTFunctionDifference(*this);
00065     }
00066 
00067 protected:
00068 
00069     virtual const XalanDOMString
00070     getError() const
00071     {
00072         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"difference()");
00073 
00074 
00075     }
00076 
00077 private:
00078 
00079     // Not implemented...
00080     XalanEXSLTFunctionDifference&
00081     operator=(const XalanEXSLTFunctionDifference&);
00082 
00083     bool
00084     operator==(const XalanEXSLTFunctionDifference&) const;
00085 };
00086 
00087 
00088 
00089 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDistinct : public FunctionDistinct
00090 {
00091 public:
00092 
00093     XalanEXSLTFunctionDistinct() :
00094         FunctionDistinct()
00095     {
00096     }
00097 
00098     virtual
00099     ~XalanEXSLTFunctionDistinct()
00100     {
00101     }
00102 
00103 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00104     virtual Function*
00105 #else
00106     virtual XalanEXSLTFunctionDistinct*
00107 #endif
00108     clone() const
00109     {
00110         return new XalanEXSLTFunctionDistinct(*this);
00111     }
00112 
00113 protected:
00114 
00115     virtual const XalanDOMString
00116     getError() const
00117     {
00118         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,"distinct()");
00119 
00120     }
00121 
00122 private:
00123 
00124     // Not implemented...
00125     XalanEXSLTFunctionDistinct&
00126     operator=(const XalanEXSLTFunctionDistinct&);
00127 
00128     bool
00129     operator==(const XalanEXSLTFunctionDistinct&) const;
00130 };
00131 
00132 
00133 
00134 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHasSameNode : public Function
00135 {
00136 public:
00137 
00138     typedef Function    ParentType;
00139 
00140     XalanEXSLTFunctionHasSameNode() :
00141         Function()
00142     {
00143     }
00144 
00145     virtual
00146     ~XalanEXSLTFunctionHasSameNode()
00147     {
00148     }
00149 
00150     // These methods are inherited from Function ...
00151 
00152     virtual XObjectPtr
00153     execute(
00154             XPathExecutionContext&          executionContext,
00155             XalanNode*                      context,
00156             const XObjectArgVectorType&     args,
00157             const LocatorType*              locator) const;
00158 
00159 #if !defined(XALAN_NO_USING_DECLARATION)
00160     using ParentType::execute;
00161 #endif
00162 
00163 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00164     virtual Function*
00165 #else
00166     virtual XalanEXSLTFunctionHasSameNode*
00167 #endif
00168     clone() const
00169     {
00170         return new XalanEXSLTFunctionHasSameNode(*this);
00171     }
00172 
00173 protected:
00174 
00175     virtual const XalanDOMString
00176     getError() const
00177     {
00178         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"has-same-node()");
00179 
00180     }
00181 
00182 private:
00183 
00184     // Not implemented...
00185     XalanEXSLTFunctionHasSameNode&
00186     operator=(const XalanEXSLTFunctionHasSameNode&);
00187 
00188     bool
00189     operator==(const XalanEXSLTFunctionHasSameNode&) const;
00190 };
00191 
00192 
00193 
00194 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionIntersection : public FunctionIntersection
00195 {
00196 public:
00197 
00198     XalanEXSLTFunctionIntersection() :
00199         FunctionIntersection()
00200     {
00201     }
00202 
00203     virtual
00204     ~XalanEXSLTFunctionIntersection()
00205     {
00206     }
00207 
00208 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00209     virtual Function*
00210 #else
00211     virtual XalanEXSLTFunctionIntersection*
00212 #endif
00213     clone() const
00214     {
00215         return new XalanEXSLTFunctionIntersection(*this);
00216     }
00217 
00218 protected:
00219 
00220     virtual const XalanDOMString
00221     getError() const
00222     {
00223         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"distinct()");
00224 
00225 
00226     }
00227 
00228 private:
00229 
00230     // Not implemented...
00231     XalanEXSLTFunctionIntersection&
00232     operator=(const XalanEXSLTFunctionIntersection&);
00233 
00234     bool
00235     operator==(const XalanEXSLTFunctionIntersection&) const;
00236 };
00237 
00238 
00239 
00240 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionLeading : public Function
00241 {
00242 public:
00243 
00244     typedef Function    ParentType;
00245 
00246     XalanEXSLTFunctionLeading() :
00247         Function()
00248     {
00249     }
00250 
00251     virtual
00252     ~XalanEXSLTFunctionLeading()
00253     {
00254     }
00255 
00256     // These methods are inherited from Function ...
00257 
00258     virtual XObjectPtr
00259     execute(
00260             XPathExecutionContext&          executionContext,
00261             XalanNode*                      context,
00262             const XObjectArgVectorType&     args,
00263             const LocatorType*              locator) const;
00264 
00265 #if !defined(XALAN_NO_USING_DECLARATION)
00266     using ParentType::execute;
00267 #endif
00268 
00269 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00270     virtual Function*
00271 #else
00272     virtual XalanEXSLTFunctionLeading*
00273 #endif
00274     clone() const
00275     {
00276         return new XalanEXSLTFunctionLeading(*this);
00277     }
00278 
00279 protected:
00280 
00281     virtual const XalanDOMString
00282     getError() const
00283     {
00284         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"leading()");
00285 
00286     }
00287 
00288 private:
00289 
00290     // Not implemented...
00291     XalanEXSLTFunctionLeading&
00292     operator=(const XalanEXSLTFunctionLeading&);
00293 
00294     bool
00295     operator==(const XalanEXSLTFunctionLeading&) const;
00296 };
00297 
00298 
00299 
00300 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTrailing : public Function
00301 {
00302 public:
00303 
00304     typedef Function    ParentType;
00305 
00306     XalanEXSLTFunctionTrailing() :
00307         Function()
00308     {
00309     }
00310 
00311     virtual
00312     ~XalanEXSLTFunctionTrailing()
00313     {
00314     }
00315 
00316     // These methods are inherited from Function ...
00317 
00318     virtual XObjectPtr
00319     execute(
00320             XPathExecutionContext&          executionContext,
00321             XalanNode*                      context,
00322             const XObjectArgVectorType&     args,
00323             const LocatorType*              locator) const;
00324 
00325 #if !defined(XALAN_NO_USING_DECLARATION)
00326     using ParentType::execute;
00327 #endif
00328 
00329 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
00330     virtual Function*
00331 #else
00332     virtual XalanEXSLTFunctionTrailing*
00333 #endif
00334     clone() const
00335     {
00336         return new XalanEXSLTFunctionTrailing(*this);
00337     }
00338 
00339 protected:
00340 
00341     virtual const XalanDOMString
00342     getError() const
00343     {
00344         return XalanMessageLoader::getMessage(XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,"trailing()");
00345     }
00346 
00347 private:
00348 
00349     // Not implemented...
00350     XalanEXSLTFunctionTrailing&
00351     operator=(const XalanEXSLTFunctionTrailing&);
00352 
00353     bool
00354     operator==(const XalanEXSLTFunctionTrailing&) const;
00355 };
00356 
00357 
00358 
00359 XALAN_CPP_NAMESPACE_END
00360 
00361 
00362 
00363 #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.8
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.