Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

XalanEXSLTStringImpl.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #if !defined(EXSLT_STRINGIMPL_HEADER_GUARD_1357924680)
17 #define EXSLT_STRINGIMPL_HEADER_GUARD_1357924680
18 
19 
20 
22 
23 
24 
26 
27 
28 
30 
31 
32 
33 XALAN_CPP_NAMESPACE_BEGIN
34 
35 
36 
38 {
39 public:
40 
42 
44  {
45  }
46 
47 
48  virtual
50  {
51  }
52 
53  // These methods are inherited from Function ...
54 
55  virtual XObjectPtr
56  execute(
57  XPathExecutionContext& executionContext,
58  XalanNode* context,
59  const XObjectArgVectorType& args,
60  const LocatorType* locator) const;
61 
62 #if !defined(XALAN_NO_USING_DECLARATION)
63  using ParentType::execute;
64 #endif
65 
66 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
67  virtual Function*
68 #else
70 #endif
71  clone(MemoryManagerType& theManager) const
72  {
73  return XalanCopyConstruct(theManager, *this);
74  }
75 
76 protected:
77 
78  const XalanDOMString&
79  getError(XalanDOMString& theBuffer) const
80  {
82  theBuffer,
83  XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
84  "align()");
85  }
86 
87 private:
88 
89  // Not implemented...
91  operator=(const XalanEXSLTFunctionAlign&);
92 
93  bool
94  operator==(const XalanEXSLTFunctionAlign&) const;
95 
96 
97  // Data members...
98  static const XalanDOMChar s_centerString[];
99  static const XalanDOMChar s_rightString[];
100 };
101 
102 
103 
105 {
106 public:
107 
109 
111  Function()
112  {
113  }
114 
115  virtual
117  {
118  }
119 
120  // These methods are inherited from Function ...
121 
122  virtual XObjectPtr
123  execute(
124  XPathExecutionContext& executionContext,
125  XalanNode* context,
126  const XObjectArgVectorType& args,
127  const LocatorType* locator) const;
128 
129 #if !defined(XALAN_NO_USING_DECLARATION)
130  using ParentType::execute;
131 #endif
132 
133 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
134  virtual Function*
135 #else
136  virtual XalanEXSLTFunctionConcat*
137 #endif
138  clone(MemoryManagerType& theManager) const
139  {
140  return XalanCopyConstruct(theManager, *this);
141  }
142 
143 protected:
144 
145  const XalanDOMString&
146  getError(XalanDOMString& theBuffer) const
147  {
149  theBuffer,
150  XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
151  "concat()");
152  }
153 
154 private:
155 
156  // Not implemented...
158  operator=(const XalanEXSLTFunctionConcat&);
159 
160  bool
161  operator==(const XalanEXSLTFunctionConcat&) const;
162 };
163 
164 
165 
167 {
168 public:
169 
171 
173  Function(),
174  m_space(s_spaceString, theManager)
175  {
176  }
177 
178  // A dummy constructor for use internally. Do not use this one!!!!
180  MemoryManagerType& theManager,
181  int /* theDummy */) :
182  Function(),
183  m_space(theManager)
184  {
185  }
186 
188  const XalanEXSLTFunctionPadding& other,
189  MemoryManagerType& theManager) :
190  Function(other),
191  m_space(s_spaceString, theManager)
192  {
193  }
194 
195  virtual
197  {
198  }
199 
200  // These methods are inherited from Function ...
201 
202  virtual XObjectPtr
203  execute(
204  XPathExecutionContext& executionContext,
205  XalanNode* context,
206  const XObjectArgVectorType& args,
207  const LocatorType* locator) const;
208 
209 #if !defined(XALAN_NO_USING_DECLARATION)
210  using ParentType::execute;
211 #endif
212 
213 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
214  virtual Function*
215 #else
217 #endif
218  clone(MemoryManagerType& theManager) const
219  {
220  return XalanCopyConstruct(theManager, *this, theManager);
221  }
222 
223 protected:
224 
225  const XalanDOMString&
226  getError(XalanDOMString& theBuffer) const
227  {
229  theBuffer,
230  XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
231  "padding()");
232  }
233 
234 private:
235 
236  // Not implemented...
238 
240  operator=(const XalanEXSLTFunctionPadding&);
241 
242  bool
244 
245 
246  // Data members...
247  const XalanDOMString m_space;
248 
249  static const XalanDOMChar s_spaceString[];
250 };
251 
252 
254 {
255 public:
256 
258 
260  Function()
261  {
262  }
263 
264  virtual
266  {
267  }
268 
269  // These methods are inherited from Function ...
270 
271  virtual XObjectPtr
272  execute(
273  XPathExecutionContext& executionContext,
274  XalanNode* context,
275  const XObjectArgVectorType& args,
276  const LocatorType* locator) const;
277 
278 #if !defined(XALAN_NO_USING_DECLARATION)
279  using ParentType::execute;
280 #endif
281 
282 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
283  virtual Function*
284 #else
286 #endif
287  clone(MemoryManagerType& theManager) const
288  {
289  return XalanCopyConstruct(theManager, *this);
290  }
291 
292 protected:
293 
294  const XalanDOMString&
295  getError(XalanDOMString& theBuffer) const
296  {
298  theBuffer,
299  XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
300  "encode-uri()");
301  }
302 
303  const XalanDOMString&
304  escapedOctet(
305  XalanDOMChar theChar,
306  XalanDOMString& theBuffer) const;
307 
308  static const XalanDOMChar s_reservedChars[];
310 
311  static const XalanDOMChar s_excludedChars[];
313 
314 private:
315 
316  // Not implemented...
318  operator=(const XalanEXSLTFunctionEncodeURI&);
319 
320  bool
322 };
323 
324 
325 
327 {
328 public:
329 
331 
333  Function()
334  {
335  }
336 
337  virtual
339  {
340  }
341 
342  // These methods are inherited from Function ...
343 
344  virtual XObjectPtr
345  execute(
346  XPathExecutionContext& executionContext,
347  XalanNode* context,
348  const XObjectArgVectorType& args,
349  const LocatorType* locator) const;
350 
351 #if !defined(XALAN_NO_USING_DECLARATION)
352  using ParentType::execute;
353 #endif
354 
355 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
356  virtual Function*
357 #else
359 #endif
360  clone(MemoryManagerType& theManager) const
361  {
362  return XalanCopyConstruct(theManager, *this);
363  }
364 
365 protected:
366 
367  const XalanDOMString&
368  getError(XalanDOMString& theBuffer) const
369  {
371  theBuffer,
372  XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
373  "decode-uri()");
374 
375  }
376 
377  XalanDOMChar
378  hexCharsToByte(
379  XPathExecutionContext& executionContext,
380  XalanNode* context,
381  const LocatorType* locator,
382  const XalanDOMChar highHexChar,
383  const XalanDOMChar lowHexChar) const;
384 
386 
387 private:
388 
389  // Not implemented...
391  operator=(const XalanEXSLTFunctionDecodeURI&);
392 
393  bool
395 };
396 
397 XALAN_CPP_NAMESPACE_END
398 
399 
400 
401 #endif // EXSLT_STRINGIMPL_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