Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


XalanEXSLTSetImpl.hpp
Go to the documentation of this file.
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 #if !defined(EXSLT_SETIMPL_HEADER_GUARD_1357924680)
19 #define EXSLT_SETIMPL_HEADER_GUARD_1357924680
20 
21 
22 
24 
25 
26 
28 
29 
30 
32 
33 
34 
38 
39 
40 
41 XALAN_CPP_NAMESPACE_BEGIN
42 
43 
44 
46 {
47 public:
48 
51  {
52  }
53 
54  virtual
56  {
57  }
58 
59 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
60  virtual Function*
61 #else
63 #endif
64  clone(MemoryManager& theManager) const
65  {
66  return XalanCopyConstruct(theManager, *this);
67  }
68 
69 protected:
70 
71  virtual const XalanDOMString&
72  getError(XalanDOMString& theBuffer) const
73  {
75  theBuffer,
76  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
77  "difference()");
78  }
79 
80 private:
81 
82  // Not implemented...
84  operator=(const XalanEXSLTFunctionDifference&);
85 
86  bool
88 };
89 
90 
91 
93 {
94 public:
95 
98  {
99  }
100 
101  virtual
103  {
104  }
105 
106 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
107  virtual Function*
108 #else
110 #endif
111  clone(MemoryManager& theManager) const
112  {
113  return XalanCopyConstruct(theManager, *this);
114  }
115 
116 protected:
117 
118  virtual const XalanDOMString&
119  getError(XalanDOMString& theBuffer) const
120  {
122  theBuffer ,
123  XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
124  "distinct()");
125  }
126 
127 
128 private:
129 
130  // Not implemented...
132  operator=(const XalanEXSLTFunctionDistinct&);
133 
134  bool
136 };
137 
138 
139 
141 {
142 public:
143 
145 
147  Function()
148  {
149  }
150 
151  virtual
153  {
154  }
155 
156  // These methods are inherited from Function ...
157 
158  virtual XObjectPtr
159  execute(
160  XPathExecutionContext& executionContext,
161  XalanNode* context,
162  const XObjectArgVectorType& args,
163  const Locator* locator) const;
164 
165  using ParentType::execute;
166 
167 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
168  virtual Function*
169 #else
171 #endif
172  clone(MemoryManager& theManager) const
173  {
174  return XalanCopyConstruct(theManager, *this);
175  }
176 
177 protected:
178 
179  virtual const XalanDOMString&
180  getError(XalanDOMString& theBuffer) const
181  {
183  theBuffer,
184  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
185  "has-same-node()");
186  }
187 
188 
189 
190 private:
191 
192  // Not implemented...
194  operator=(const XalanEXSLTFunctionHasSameNode&);
195 
196  bool
198 };
199 
200 
201 
203 {
204 public:
205 
208  {
209  }
210 
211  virtual
213  {
214  }
215 
216 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
217  virtual Function*
218 #else
220 #endif
221  clone(MemoryManager& theManager) const
222  {
223  return XalanCopyConstruct(theManager, *this);
224  }
225 
226 protected:
227 
228  virtual const XalanDOMString&
229  getError(XalanDOMString& theBuffer) const
230  {
232  theBuffer,
233  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
234  "distinct()");
235  }
236 
237 private:
238 
239  // Not implemented...
241  operator=(const XalanEXSLTFunctionIntersection&);
242 
243  bool
245 };
246 
247 
248 
250 {
251 public:
252 
254 
256  Function()
257  {
258  }
259 
260  virtual
262  {
263  }
264 
265  // These methods are inherited from Function ...
266 
267  virtual XObjectPtr
268  execute(
269  XPathExecutionContext& executionContext,
270  XalanNode* context,
271  const XObjectArgVectorType& args,
272  const Locator* locator) const;
273 
274  using ParentType::execute;
275 
276 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
277  virtual Function*
278 #else
280 #endif
281  clone(MemoryManager& theManager) const
282  {
283  return XalanCopyConstruct(theManager, *this);
284  }
285 
286 protected:
287 
288  virtual const XalanDOMString&
289  getError(XalanDOMString& theBuffer) const
290  {
292  theBuffer,
293  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
294  "leading()");
295  }
296 
297 private:
298 
299  // Not implemented...
301  operator=(const XalanEXSLTFunctionLeading&);
302 
303  bool
305 };
306 
307 
308 
310 {
311 public:
312 
314 
316  Function()
317  {
318  }
319 
320  virtual
322  {
323  }
324 
325  // These methods are inherited from Function ...
326 
327  virtual XObjectPtr
328  execute(
329  XPathExecutionContext& executionContext,
330  XalanNode* context,
331  const XObjectArgVectorType& args,
332  const Locator* locator) const;
333 
334  using ParentType::execute;
335 
336 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
337  virtual Function*
338 #else
340 #endif
341  clone(MemoryManager& theManager) const
342  {
343  return XalanCopyConstruct(theManager, *this);
344  }
345 
346 protected:
347 
348  virtual const XalanDOMString&
349  getError(XalanDOMString& theBuffer) const
350  {
352  theBuffer,
353  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
354  "trailing()");
355  }
356 
357 private:
358 
359  // Not implemented...
361  operator=(const XalanEXSLTFunctionTrailing&);
362 
363  bool
365 };
366 
367 
368 
369 XALAN_CPP_NAMESPACE_END
370 
371 
372 
373 #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.11
Copyright © 1999-2012 The Apache Software Foundation.
All Rights Reserved.

Apache Logo