Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


XalanEXSLTStringImpl.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_STRINGIMPL_HEADER_GUARD_1357924680)
19 #define EXSLT_STRINGIMPL_HEADER_GUARD_1357924680
20 
21 
22 
24 
25 
26 
28 
29 
30 
32 
33 
34 
35 XALAN_CPP_NAMESPACE_BEGIN
36 
37 
38 
40 {
41 public:
42 
44 
46  {
47  }
48 
49 
50  virtual
52  {
53  }
54 
55  // These methods are inherited from Function ...
56 
57  virtual XObjectPtr
58  execute(
59  XPathExecutionContext& executionContext,
60  XalanNode* context,
61  const XObjectArgVectorType& args,
62  const Locator* locator) const;
63 
64  using ParentType::execute;
65 
66 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
67  virtual Function*
68 #else
70 #endif
71  clone(MemoryManager& 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 Locator* locator) const;
128 
129  using ParentType::execute;
130 
131 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
132  virtual Function*
133 #else
134  virtual XalanEXSLTFunctionConcat*
135 #endif
136  clone(MemoryManager& theManager) const
137  {
138  return XalanCopyConstruct(theManager, *this);
139  }
140 
141 protected:
142 
143  const XalanDOMString&
144  getError(XalanDOMString& theBuffer) const
145  {
147  theBuffer,
148  XalanMessages::EXSLTFunctionAcceptsOneArgument_1Param,
149  "concat()");
150  }
151 
152 private:
153 
154  // Not implemented...
156  operator=(const XalanEXSLTFunctionConcat&);
157 
158  bool
159  operator==(const XalanEXSLTFunctionConcat&) const;
160 };
161 
162 
163 
165 {
166 public:
167 
169 
170  XalanEXSLTFunctionPadding(MemoryManager& theManager) :
171  Function(),
172  m_space(s_spaceString, theManager)
173  {
174  }
175 
176  // A dummy constructor for use internally. Do not use this one!!!!
178  MemoryManager& theManager,
179  int /* theDummy */) :
180  Function(),
181  m_space(theManager)
182  {
183  }
184 
186  const XalanEXSLTFunctionPadding& other,
187  MemoryManager& theManager) :
188  Function(other),
189  m_space(s_spaceString, theManager)
190  {
191  }
192 
193  virtual
195  {
196  }
197 
198  // These methods are inherited from Function ...
199 
200  virtual XObjectPtr
201  execute(
202  XPathExecutionContext& executionContext,
203  XalanNode* context,
204  const XObjectArgVectorType& args,
205  const Locator* locator) const;
206 
207  using ParentType::execute;
208 
209 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
210  virtual Function*
211 #else
213 #endif
214  clone(MemoryManager& theManager) const
215  {
216  return XalanCopyConstruct(theManager, *this, theManager);
217  }
218 
219 protected:
220 
221  const XalanDOMString&
222  getError(XalanDOMString& theBuffer) const
223  {
225  theBuffer,
226  XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
227  "padding()");
228  }
229 
230 private:
231 
232  // Not implemented...
234 
236  operator=(const XalanEXSLTFunctionPadding&);
237 
238  bool
240 
241 
242  // Data members...
243  const XalanDOMString m_space;
244 
245  static const XalanDOMChar s_spaceString[];
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  const XalanDOMString&
289  getError(XalanDOMString& theBuffer) const
290  {
292  theBuffer,
293  XalanMessages::EXSLTFunctionAcceptsTwoOrThreeArguments_1Param,
294  "encode-uri()");
295  }
296 
297  const XalanDOMString&
298  escapedOctet(
299  XalanDOMChar theChar,
300  XalanDOMString& theBuffer) const;
301 
302  static const XalanDOMChar s_reservedChars[];
304 
305  static const XalanDOMChar s_excludedChars[];
307 
308 private:
309 
310  // Not implemented...
312  operator=(const XalanEXSLTFunctionEncodeURI&);
313 
314  bool
316 };
317 
318 
319 
321 {
322 public:
323 
325 
327  Function()
328  {
329  }
330 
331  virtual
333  {
334  }
335 
336  // These methods are inherited from Function ...
337 
338  virtual XObjectPtr
339  execute(
340  XPathExecutionContext& executionContext,
341  XalanNode* context,
342  const XObjectArgVectorType& args,
343  const Locator* locator) const;
344 
345  using ParentType::execute;
346 
347 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
348  virtual Function*
349 #else
351 #endif
352  clone(MemoryManager& theManager) const
353  {
354  return XalanCopyConstruct(theManager, *this);
355  }
356 
357 protected:
358 
359  const XalanDOMString&
360  getError(XalanDOMString& theBuffer) const
361  {
363  theBuffer,
364  XalanMessages::EXSLTFunctionAccepts1Or2Argument_1Param,
365  "decode-uri()");
366 
367  }
368 
369  XalanDOMChar
370  hexCharsToByte(
371  XPathExecutionContext& executionContext,
372  XalanNode* context,
373  const Locator* locator,
374  const XalanDOMChar highHexChar,
375  const XalanDOMChar lowHexChar) const;
376 
378 
379 private:
380 
381  // Not implemented...
383  operator=(const XalanEXSLTFunctionDecodeURI&);
384 
385  bool
387 };
388 
389 XALAN_CPP_NAMESPACE_END
390 
391 
392 
393 #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.

Xalan-C++ XSLT Processor Version 1.11
Copyright © 1999-2012 The Apache Software Foundation.
All Rights Reserved.

Apache Logo