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
Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.
Xalan-C++ XSLT Processor Version 1.9 |
|