00001 /* 00002 * Licensed to the Apache Software Foundation (ASF) under one 00003 * or more contributor license agreements. See the NOTICE file 00004 * distributed with this work for additional information 00005 * regarding copyright ownership. The ASF licenses this file 00006 * to you under the Apache License, Version 2.0 (the "License"); 00007 * you may not use this file except in compliance with the License. 00008 * You may obtain a copy of the License at 00009 * 00010 * http://www.apache.org/licenses/LICENSE-2.0 00011 * 00012 * Unless required by applicable law or agreed to in writing, software 00013 * distributed under the License is distributed on an "AS IS" BASIS, 00014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00015 * See the License for the specific language governing permissions and 00016 * limitations under the License. 00017 */ 00018 #if !defined(EXSLT_SETIMPL_HEADER_GUARD_1357924680) 00019 #define EXSLT_SETIMPL_HEADER_GUARD_1357924680 00020 00021 00022 00023 #include "XalanEXSLTDefinitions.hpp" 00024 00025 00026 00027 #include <xalanc/PlatformSupport/XalanMessageLoader.hpp> 00028 00029 00030 00031 #include <xalanc/XPath/Function.hpp> 00032 00033 00034 00035 #include <xalanc/XalanExtensions/FunctionDifference.hpp> 00036 #include <xalanc/XalanExtensions/FunctionDistinct.hpp> 00037 #include <xalanc/XalanExtensions/FunctionIntersection.hpp> 00038 00039 00040 00041 XALAN_CPP_NAMESPACE_BEGIN 00042 00043 00044 00045 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDifference : public FunctionDifference 00046 { 00047 public: 00048 00049 XalanEXSLTFunctionDifference() : 00050 FunctionDifference() 00051 { 00052 } 00053 00054 virtual 00055 ~XalanEXSLTFunctionDifference() 00056 { 00057 } 00058 00059 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00060 virtual Function* 00061 #else 00062 virtual XalanEXSLTFunctionDifference* 00063 #endif 00064 clone(MemoryManager& theManager) const 00065 { 00066 return XalanCopyConstruct(theManager, *this); 00067 } 00068 00069 protected: 00070 00071 virtual const XalanDOMString& 00072 getError(XalanDOMString& theBuffer) const 00073 { 00074 return XalanMessageLoader::getMessage( 00075 theBuffer, 00076 XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param, 00077 "difference()"); 00078 } 00079 00080 private: 00081 00082 // Not implemented... 00083 XalanEXSLTFunctionDifference& 00084 operator=(const XalanEXSLTFunctionDifference&); 00085 00086 bool 00087 operator==(const XalanEXSLTFunctionDifference&) const; 00088 }; 00089 00090 00091 00092 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionDistinct : public FunctionDistinct 00093 { 00094 public: 00095 00096 XalanEXSLTFunctionDistinct() : 00097 FunctionDistinct() 00098 { 00099 } 00100 00101 virtual 00102 ~XalanEXSLTFunctionDistinct() 00103 { 00104 } 00105 00106 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00107 virtual Function* 00108 #else 00109 virtual XalanEXSLTFunctionDistinct* 00110 #endif 00111 clone(MemoryManager& theManager) const 00112 { 00113 return XalanCopyConstruct(theManager, *this); 00114 } 00115 00116 protected: 00117 00118 virtual const XalanDOMString& 00119 getError(XalanDOMString& theBuffer) const 00120 { 00121 return XalanMessageLoader::getMessage( 00122 theBuffer , 00123 XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param, 00124 "distinct()"); 00125 } 00126 00127 00128 private: 00129 00130 // Not implemented... 00131 XalanEXSLTFunctionDistinct& 00132 operator=(const XalanEXSLTFunctionDistinct&); 00133 00134 bool 00135 operator==(const XalanEXSLTFunctionDistinct&) const; 00136 }; 00137 00138 00139 00140 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionHasSameNode : public Function 00141 { 00142 public: 00143 00144 typedef Function ParentType; 00145 00146 XalanEXSLTFunctionHasSameNode() : 00147 Function() 00148 { 00149 } 00150 00151 virtual 00152 ~XalanEXSLTFunctionHasSameNode() 00153 { 00154 } 00155 00156 // These methods are inherited from Function ... 00157 00158 virtual XObjectPtr 00159 execute( 00160 XPathExecutionContext& executionContext, 00161 XalanNode* context, 00162 const XObjectArgVectorType& args, 00163 const Locator* locator) const; 00164 00165 using ParentType::execute; 00166 00167 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00168 virtual Function* 00169 #else 00170 virtual XalanEXSLTFunctionHasSameNode* 00171 #endif 00172 clone(MemoryManager& 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(MemoryManager& 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 Locator* locator) const; 00273 00274 using ParentType::execute; 00275 00276 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00277 virtual Function* 00278 #else 00279 virtual XalanEXSLTFunctionLeading* 00280 #endif 00281 clone(MemoryManager& theManager) const 00282 { 00283 return XalanCopyConstruct(theManager, *this); 00284 } 00285 00286 protected: 00287 00288 virtual const XalanDOMString& 00289 getError(XalanDOMString& theBuffer) const 00290 { 00291 return XalanMessageLoader::getMessage( 00292 theBuffer, 00293 XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param, 00294 "leading()"); 00295 } 00296 00297 private: 00298 00299 // Not implemented... 00300 XalanEXSLTFunctionLeading& 00301 operator=(const XalanEXSLTFunctionLeading&); 00302 00303 bool 00304 operator==(const XalanEXSLTFunctionLeading&) const; 00305 }; 00306 00307 00308 00309 class XALAN_EXSLT_EXPORT XalanEXSLTFunctionTrailing : public Function 00310 { 00311 public: 00312 00313 typedef Function ParentType; 00314 00315 XalanEXSLTFunctionTrailing() : 00316 Function() 00317 { 00318 } 00319 00320 virtual 00321 ~XalanEXSLTFunctionTrailing() 00322 { 00323 } 00324 00325 // These methods are inherited from Function ... 00326 00327 virtual XObjectPtr 00328 execute( 00329 XPathExecutionContext& executionContext, 00330 XalanNode* context, 00331 const XObjectArgVectorType& args, 00332 const Locator* locator) const; 00333 00334 using ParentType::execute; 00335 00336 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE) 00337 virtual Function* 00338 #else 00339 virtual XalanEXSLTFunctionTrailing* 00340 #endif 00341 clone(MemoryManager& theManager) const 00342 { 00343 return XalanCopyConstruct(theManager, *this); 00344 } 00345 00346 protected: 00347 00348 virtual const XalanDOMString& 00349 getError(XalanDOMString& theBuffer) const 00350 { 00351 return XalanMessageLoader::getMessage( 00352 theBuffer, 00353 XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param, 00354 "trailing()"); 00355 } 00356 00357 private: 00358 00359 // Not implemented... 00360 XalanEXSLTFunctionTrailing& 00361 operator=(const XalanEXSLTFunctionTrailing&); 00362 00363 bool 00364 operator==(const XalanEXSLTFunctionTrailing&) const; 00365 }; 00366 00367 00368 00369 XALAN_CPP_NAMESPACE_END 00370 00371 00372 00373 #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.11 |
|