Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


StylesheetConstructionContextDefault.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(STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680)
19 #define STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
20 
21 
22 
23 // Base include file. Must be first.
25 
26 
27 
29 
30 
31 
35 
36 
37 
38 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) || defined(XALAN_BUILD_DLL)
40 #endif
41 
42 
43 
45 
46 
47 
49 
50 
51 
55 
56 
57 
58 // Base class header file...
60 
61 
62 
63 #include <xalanc/XSLT/AVT.hpp>
80 
81 
82 
83 XALAN_CPP_NAMESPACE_BEGIN
84 
85 
86 
87 class XPathEnvSupport;
88 class XPathFactory;
89 class XPathProcessor;
90 class XSLTEngineImpl;
91 
92 
93 
94 /**
95  *
96  * An default implementation of an abtract class which provides support for
97  * constructing the internal representation of a stylesheet.
98  *
99  */
101 {
102 public:
103 
107 
108  // Default size for vector allocation.
109  enum {
110  eDefaultXalanDOMCharVectorBlockSize = 1024,
111  eDefaultAVTBlockSize = 128,
112  eDefaultAVTPartSimpleBlockSize = 128,
113  eDefaultAVTPartXPathBlockSize = 128,
114  eDefaultXalanQNameByValueBlockSize = 32,
115  eDefaultPointerVectorBlockSize = 512,
116  eDefaultElemApplyTemplatesBlockSize = 10,
117  eDefaultElemAttributeBlockSize = 10,
118  eDefaultElemAttributeSetBlockSize = 10,
119  eDefaultElemCallTemplateBlockSize = 10,
120  eDefaultElemElementBlockSize = 10,
121  eDefaultElemLiteralResultBlockSize = 20,
122  eDefaultElemTemplateBlockSize = 10,
123  eDefaultElemTextLiteralBlockSize = 20,
124  eDefaultElemValueOfBlockSize = 10,
125  eDefaultElemVariableBlockSize = 10,
126  eDefaultMatchPatternDataBlockSize = 10 };
127 
128  /*
129  * Construct an instance. If the stylesheet(s) constructed is/are meant to be reused (a.k.a. "compiled"),
130  * the XObjectFactory and XPathFactory instance must exist for the lifetime of the construction context
131  * and, therefore, for the lifetime of the stylesheet(s). Otherwise, XObject and XPath instance will be
132  * destroyed when the corresponding factories are destryed, leaving pointers to destroyed objects in the.
133  * stylesheet(s).
134  *
135  * @param processor a reference to an XSLTEngineImpl instance. Used for error reporting.
136  * @param xpathFactory a reference to an XPathFactory instance. See comments above for important details.
137  * @param theXalanDOMCharVectorAllocatorBlockSize The block size to use for allocating vectors of XalanDOMChars
138  * @param theAVTAllocatorBlockSize The block size to use for allocating AVT instances.
139  * @param theAVTPartSimpleAllocatorBlockSize The block size to use for allocating AVTPartSimple instances.
140  * @param theAVTPartXPathAllocatorBlockSize The block size to use for allocating AVTPartXPath instances.
141  * @param theXalanQNameByValueAllocatorBlockSize The block size to use for allocating XalanQNameByValue instances.
142  * @param thePointerVectorAllocatorBlockSize The block size to use for allocating vectors of pointers.
143  */
145  MemoryManager& theManager,
146  XSLTEngineImpl& processor,
147  XPathFactory& xpathFactory,
148  VectorAllocatorSizeType theXalanDOMCharVectorAllocatorBlockSize = eDefaultXalanDOMCharVectorBlockSize,
149  XalanAVTAllocator::size_type theAVTAllocatorBlockSize = eDefaultAVTBlockSize,
150  XalanAVTPartSimpleAllocator::size_type theAVTPartSimpleAllocatorBlockSize = eDefaultAVTPartSimpleBlockSize,
151  XalanAVTPartXPathAllocator::size_type theAVTPartXPathAllocatorBlockSize = eDefaultAVTPartXPathBlockSize,
152  XalanQNameByValueAllocator::size_type theXalanQNameByValueAllocatorBlockSize = eDefaultXalanQNameByValueBlockSize,
153  VectorAllocatorSizeType thePointerVectorAllocatorBlockSize = eDefaultPointerVectorBlockSize);
154 
155  virtual
157 
158 
159  // These interfaces are inherited from StylesheetConstructionContext...
160 
161  virtual void
162  problem(
163  eSource source,
164  eClassification classification,
165  const XalanDOMString& msg,
166  const Locator* locator,
167  const XalanNode* sourceNode);
168 
169  virtual void
170  problem(
171  eSource source,
172  eClassification classification,
173  const XalanDOMString& msg,
174  const XalanNode* sourceNode);
175 
176  virtual void
177  reset();
178 
179  virtual const XalanDOMString&
180  getPooledString(const XalanDOMString& theString);
181 
182  virtual const XalanDOMString&
184  const XalanDOMChar* theString,
186 
187  virtual XalanDOMString&
188  getCachedString();
189 
190  virtual bool
192 
193  virtual StylesheetRoot*
194  create(const XalanDOMString& theBaseIdentifier);
195 
196  virtual StylesheetRoot*
197  create(const XSLTInputSource& theInputSource);
198 
199  virtual Stylesheet*
200  create(
201  StylesheetRoot& theStylesheetRoot,
202  const XalanDOMString& theBaseIdentifier);
203 
204  virtual void
205  destroy(StylesheetRoot* theStylesheetRoot);
206 
207  virtual URLAutoPtrType
208  getURLFromString(const XalanDOMString& urlString);
209 
210  virtual XalanDOMString&
212  const XalanDOMString& urlString,
213  XalanDOMString& theResult);
214 
215  virtual URLAutoPtrType
217  const XalanDOMString& urlString,
218  const XalanDOMString& base);
219 
220  virtual XalanDOMString&
222  const XalanDOMString& urlString,
223  const XalanDOMString& base,
224  XalanDOMString& theResult);
225 
226  virtual const XalanDOMString&
227  getXSLTNamespaceURI() const;
228 
229  virtual XPath*
231  const Locator* locator,
232  const XalanDOMString& str,
233  const PrefixResolver& resolver,
234  bool allowVariableReferences = true,
235  bool allowKeyFunction = true);
236 
237  virtual XPath*
239  const Locator* locator,
240  const XalanDOMChar* str,
241  const PrefixResolver& resolver,
242  bool allowVariableReferences = true,
243  bool allowKeyFunction = true);
244 
245  virtual XPath*
246  createXPath(
247  const Locator* locator,
248  const XalanDOMString& str,
249  const PrefixResolver& resolver,
250  bool allowVariableReferences = true,
251  bool allowKeyFunction = true);
252 
253  virtual XPath*
254  createXPath(
255  const Locator* locator,
256  const XalanDOMChar* str,
257  const PrefixResolver& resolver,
258  bool allowVariableReferences = true,
259  bool allowKeyFunction = true);
260 
261  virtual XPath*
262  createXPath(
263  const Locator* locator,
264  const XalanDOMChar* str,
266  const PrefixResolver& resolver,
267  bool allowVariableReferences = true,
268  bool allowKeyFunction = true);
269 
270  virtual const Locator*
271  getLocatorFromStack() const;
272 
273  virtual void
274  pushLocatorOnStack(const Locator* locator);
275 
276  virtual void
277  popLocatorStack();
278 
279  virtual const XalanDOMString&
280  getXalanXSLNameSpaceURL() const;
281 
282  virtual XalanDocument*
283  parseXML(
284  const XalanDOMString& urlString,
285  DocumentHandler* docHandler,
286  XalanDocument* docToRegister,
287  ErrorHandler* theErrorHandler = 0);
288 
289  virtual bool
291  const XalanDOMChar* theAttributeName,
292  const Stylesheet& theStylesheet,
293  const Locator* theLocator = 0);
294 
295  virtual bool
297  const XalanDOMChar* theAttributeName,
298  const Stylesheet& theStylesheet,
299  const Locator* theLocator = 0);
300 
301  virtual bool
302  isValidQName(
303  const XalanDOMChar* theName,
304  const Stylesheet& theStylesheet,
305  const Locator* theLocator = 0);
306 
307  virtual eElementToken
308  getElementToken(const XalanDOMString& name) const;
309 
310  virtual double
311  getXSLTVersionSupported() const;
312 
313  virtual XalanDOMChar*
315 
316  virtual XalanDOMChar*
318  const XalanDOMChar* theString,
320  bool fTerminate = true);
321 
322  virtual const AVT*
323  createAVT(
324  const Locator* locator,
325  const XalanDOMChar* name,
326  const XalanDOMChar* stringedValue,
327  const PrefixResolver& resolver);
328 
329  virtual const AVTPart*
331  const XalanDOMChar* theString,
333 
334  virtual const AVTPart*
336  const Locator* locator,
337  const XalanDOMChar* str,
339  const PrefixResolver& resolver);
340 
341  virtual const AVT**
343 
344  virtual const AVTPart**
346 
347  virtual const XalanQName*
349  const XalanDOMString& qname,
350  const NamespacesStackType& namespaces,
351  const Locator* locator = 0,
352  bool fUseDefault = false);
353 
354  virtual const XalanQName*
356  const XalanDOMChar* qname,
357  const NamespacesStackType& namespaces,
358  const Locator* locator = 0,
359  bool fUseDefault = false);
360 
361  virtual const XalanQName**
363  size_type& count,
364  const XalanDOMChar* qnameTokens,
365  const NamespacesStackType& namespaces,
366  const Locator* locator = 0,
367  bool fUseDefault = false);
368 
369  virtual ElemTemplateElement*
371  int token,
372  Stylesheet& stylesheetTree,
373  const AttributeListType& atts,
374  const Locator* locator = 0);
375 
376  virtual ElemTemplateElement*
378  int token,
379  Stylesheet& stylesheetTree,
380  const XalanDOMChar* name,
381  const AttributeListType& atts,
382  const Locator* locator = 0);
383 
384  virtual ElemTemplateElement*
386  Stylesheet& stylesheetTree,
387  const XalanDOMChar* chars,
389  bool preserveSpace,
390  bool disableOutputEscaping,
391  const Locator* locator = 0);
392 
393  virtual ElemTemplateElement*
395  Stylesheet& stylesheetTree,
396  const XalanDOMChar* name,
397  const AttributeListType& atts,
398  ExtensionNSHandler& handler,
399  const Locator* locator = 0);
400 
401  virtual const XalanMatchPatternData*
403  const ElemTemplate& theTemplate,
404  size_type thePosition,
405  const XalanDOMString& theTargetString,
406  const XPath& theMatchPattern,
407  const XalanDOMString& thePatternString,
408  XPath::eMatchScore thePriority);
409 
410  static eElementToken
411  getElementNameToken(const XalanDOMString& name);
412 
415 
416 private:
417 
418  const AVT**
419  doAllocateAVTPointerVector(size_type theSize)
420  {
421  assert(sizeof(AVT**) == sizeof(PointerVectorAllocatorType::value_type));
422 
423  return reinterpret_cast<const AVT**>(m_pointerVectorAllocator.allocate(theSize));
424  }
425 
426  const AVTPart**
427  doAllocateAVTPartPointerVector(size_type theSize)
428  {
429  assert(sizeof(AVTPart**) == sizeof(PointerVectorAllocatorType::value_type));
430 
431  return reinterpret_cast<const AVTPart**>(m_pointerVectorAllocator.allocate(theSize));
432  }
433 
434  const XalanQName**
435  doAllocateXalanQNamePointerVector(size_type theSize)
436  {
437  assert(sizeof(XalanQName**) == sizeof(PointerVectorAllocatorType::value_type));
438 
439  return reinterpret_cast<const XalanQName**>(m_pointerVectorAllocator.allocate(theSize));
440  }
441 
442 
443  XSLTEngineImpl& m_processor;
444 
445  XPathFactory& m_xpathFactory;
446 
448 
449  XPathProcessAutoPtr m_xpathProcessor;
450 
451  StylesheetVectorType m_stylesheets;
452 
453  XalanDOMStringPool m_stringPool;
454 
455  XalanDOMCharVectorAllocatorType m_xalanDOMCharVectorAllocator;
456 
457  mutable XalanDOMString m_tempBuffer;
458 
459  XalanQNameByValue m_scratchQName;
460 
461  XalanDOMStringCache m_stringCache;
462 
463  XalanAVTAllocator m_avtAllocator;
464 
465  XalanAVTPartSimpleAllocator m_avtPartSimpleAllocator;
466 
467  XalanAVTPartXPathAllocator m_avtPartXPathAllocator;
468 
469  XalanQNameByValueAllocator m_xalanQNameByValueAllocator;
470 
471  const XalanQNameByReference m_useAttributeSetsQName;
472 
473  PointerVectorAllocatorType m_pointerVectorAllocator;
474 
475  ElemTemplateElementVectorType m_allocatedElements;
476 
477  XalanElemApplyTemplatesAllocator m_elemApplyTemplatesAllocator;
478 
479  XalanElemAttributeAllocator m_elemAttributeAllocator;
480 
481  XalanElemAttributeSetAllocator m_elemAttributeSetAllocator;
482 
483  XalanElemCallTemplateAllocator m_elemCallTemplateAllocator;
484 
485  XalanElemElementAllocator m_elemElementAllocator;
486 
487  XalanElemLiteralResultAllocator m_elemLiteralResultAllocator;
488 
489  XalanElemTemplateAllocator m_elemTemplateAllocator;
490 
491  XalanElemTextLiteralAllocator m_elemTextLiteralAllocator;
492 
493  XalanElemValueOfAllocator m_elemValueOfAllocator;
494 
495  XalanElemVariableAllocator m_elemVariableAllocator;
496 
497  XalanMatchPatternDataAllocator m_matchPatternDataAllocator;
498 
499  const XalanQNameByReference m_spaceAttrQName;
500 
501  // Static strings for stylesheet compilation...
502 
503  // The string "if"
504  static const XalanDOMChar s_if[];
505 
506  // The string "key"
507  static const XalanDOMChar s_key[];
508 
509  // The string "copy"
510  static const XalanDOMChar s_copy[];
511 
512  // The string "sort"
513  static const XalanDOMChar s_sort[];
514 
515  // The string "text"
516  static const XalanDOMChar s_text[];
517 
518  // The string "when"
519  static const XalanDOMChar s_when[];
520 
521  // The string "empty"
522  static const XalanDOMChar s_empty[];
523 
524  // The string "param"
525  static const XalanDOMChar s_param[];
526 
527  // The string "choose"
528  static const XalanDOMChar s_choose[];
529 
530  // The string "import"
531  static const XalanDOMChar s_import[];
532 
533  // The string "number"
534  static const XalanDOMChar s_number[];
535 
536  // The string "output"
537  static const XalanDOMChar s_output[];
538 
539  // The string "comment"
540  static const XalanDOMChar s_comment[];
541 
542  // The string "copy-of"
543  static const XalanDOMChar s_copyOf[];
544 
545  // The string "element"
546  static const XalanDOMChar s_element[];
547 
548  // The string "include"
549  static const XalanDOMChar s_include[];
550 
551  // The string "message"
552  static const XalanDOMChar s_message[];
553 
554  // The string "fallback"
555  static const XalanDOMChar s_fallback[];
556 
557  // The string "for-each"
558  static const XalanDOMChar s_forEach[];
559 
560  // The string "template"
561  static const XalanDOMChar s_template[];
562 
563  // The string "value-of"
564  static const XalanDOMChar s_valueOf[];
565 
566  // The string "variable"
567  static const XalanDOMChar s_variable[];
568 
569  // The string "attribute"
570  static const XalanDOMChar s_attribute[];
571 
572  // The string "otherwise"
573  static const XalanDOMChar s_otherwise[];
574 
575  // The string "transform"
576  static const XalanDOMChar s_transform[];
577 
578  // The string "stylesheet"
579  static const XalanDOMChar s_stylesheet[];
580 
581  // The string "with-param"
582  static const XalanDOMChar s_withParam[];
583 
584  // The string "strip-space"
585  static const XalanDOMChar s_stripSpace[];
586 
587  // The string "apply-imports"
588  static const XalanDOMChar s_applyImports[];
589 
590  // The string "attribute-set"
591  static const XalanDOMChar s_attributeSet[];
592 
593  // The string "call-template"
594  static const XalanDOMChar s_callTemplate[];
595 
596  // The string "decimal-format"
597  static const XalanDOMChar s_decimalFormat[];
598 
599  // The string "preserve-space"
600  static const XalanDOMChar s_preserveSpace[];
601 
602  // The string "apply-templates"
603  static const XalanDOMChar s_applyTemplates[];
604 
605  // The string "namespace-alias"
606  static const XalanDOMChar s_namespaceAlias[];
607 
608  // The string "processing-instruction"
609  static const XalanDOMChar s_processingInstruction[];
610 
611  // A struct for an array that maps stylesheet element names
612  // to int tokens.
613  struct ElementTokenTableEntry
614  {
615  const XalanDOMChar* m_name;
616 
617  eElementToken m_token;
618  };
619 
620  static const ElementTokenTableEntry s_elementTokenTable[];
621 
622  static const XalanSize_t s_elementTokenTableSize;
623 
624  static const ElementTokenTableEntry& s_elementTokenTableLast;
625 
626  static const ElementTokenTableEntry& s_elementTokenTableDummy;
627 };
628 
629 
630 
631 XALAN_CPP_NAMESPACE_END
632 
633 
634 
635 #endif // STYLESHEETCONSTRUCTIONCONTEXTDEFAULT_HEADER_GUARD_1357924680
virtual const AVT * createAVT(const Locator *locator, const XalanDOMChar *name, const XalanDOMChar *stringedValue, const PrefixResolver &resolver)=0
Create an AVT instance.
virtual const XalanQName ** tokenizeQNames(size_type &count, const XalanDOMChar *qnameTokens, const NamespacesStackType &namespaces, const Locator *locator=0, bool fUseDefault=false)=0
Tokenize a string and return the QNames corresponding to those tokens.
virtual ElemTemplateElement * createElement(int token, Stylesheet &stylesheetTree, const AttributeList &atts, const Locator *locator=0)=0
Create a stylesheet element for the provided type.
ArenaAllocatorType::size_type size_type
virtual const XalanDOMString & getXSLTNamespaceURI() const =0
Retrieve the URI for the current XSLT namespace, for example, "http://www.w3.org/1999/XSL/Transform"...
virtual XPath * createXPath(const Locator *locator, const XalanDOMString &str, const PrefixResolver &resolver, bool allowVariableReferences=true, bool allowKeyFunction=true)=0
Create and initialize an xpath and return it.
XalanVector< ElemTemplateElement * > ElemTemplateElementVectorType
This class contains information concerning a match pattern in a stylesheet.
virtual const Locator * getLocatorFromStack() const =0
Get the locator from the top of the locator stack.
virtual void pushLocatorOnStack(const Locator *locator)=0
Push a locator on to the locator stack.
virtual void popLocatorStack()=0
Pop the locator from the top of the locator stack.
virtual StylesheetRoot * create(const XalanDOMString &theBaseIdentifier)=0
Create a new StylesheetRoot instance.
eMatchScore
Definition: XPath.hpp:86
This acts as the stylesheet root of the stylesheet tree, and holds values that are shared by all styl...
virtual URLAutoPtrType getURLFromString(const XalanDOMString &urlString)=0
Determine the fully qualified URI for a string.
virtual XalanDOMString & getCachedString()=0
Get a cached string for temporary use.
virtual XalanDOMString & getURLStringFromString(const XalanDOMString &urlString, XalanDOMString &theResult)=0
Determine the fully qualified URI for a string.
Definition: XPath.hpp:64
virtual bool releaseCachedString(XalanDOMString &theString)=0
Return a cached string.
virtual void reset()=0
Reset the instance.
XalanSize_t size_type
virtual const AVT ** allocateAVTPointerVector(size_type theLength)=0
Allocate a vector of const AVT* of the specified length.
It&#39;s the responsibility of the XSLTEngineImpl class, collaborating with the XML parser liaison...
virtual const XalanDOMString & getXalanXSLNameSpaceURL() const =0
Get the Xalan namespace for built-in extensions.
virtual void problem(eSource source, eClassification classification, const XalanDOMString &msg, const Locator *locator, const XalanNode *sourceNode)=0
Function that is called when a problem event occurs.
virtual XalanDOMChar * allocateXalanDOMCharVector(XalanDOMString::size_type theLength)=0
Allocate a vector of XalanDOMChar of the specified size.
virtual bool isXSLUseAttributeSetsAttribute(const XalanDOMChar *theAttributeName, const Stylesheet &theStylesheet, const Locator *theLocator=0)=0
Given an name, determine if it is the xsl:use-attribute-sets attribute.
virtual void destroy(StylesheetRoot *theStylesheetRoot)=0
Destroy a StylesheetRoot instance.
virtual const XalanQName * createXalanQName(const XalanDOMString &qname, const NamespacesStackType &namespaces, const Locator *locator=0, bool fUseDefault=false)=0
Create a XalanQName-derived instance.
virtual const XalanDOMString & getPooledString(const XalanDOMString &theString)=0
Get a pooled string given the source string.
Class to hold a part, either a string or XPath, of an Attribute Value Template.
Definition: AVTPart.hpp:43
ArenaAllocatorType::size_type size_type
virtual bool isValidQName(const XalanDOMChar *theName, const Stylesheet &theStylesheet, const Locator *theLocator=0)=0
Given an name, determine if it is a valid QName.
Class to hold an Attribute Value Template.
Definition: AVT.hpp:55
virtual XalanDocument * parseXML(const XalanDOMString &urlString, DocumentHandler *docHandler, XalanDocument *docToRegister, ErrorHandler *theErrorHandler=0)=0
Read in the XML file, either producing a Document or calling SAX events, and register the document in...
XALAN_CPP_NAMESPACE_BEGIN typedef size_t size_type
Definition: XalanMap.hpp:46
XalanDOMCharVectorAllocatorType::size_type VectorAllocatorSizeType
virtual XPath * createMatchPattern(const Locator *locator, const XalanDOMString &str, const PrefixResolver &resolver, bool allowVariableReferences=true, bool allowKeyFunction=true)=0
Create and initialize an xpath for a match pattern and return it.
ArenaAllocatorType::size_type size_type
virtual const AVTPart ** allocateAVTPartPointerVector(size_type theLength)=0
Allocate a vector of const AVTPart* of the specified length.
ArenaAllocatorType::size_type size_type
This class defines an interface for classes that resolve namespace prefixes to their URIs...
virtual eElementToken getElementToken(const XalanDOMString &name) const =0
Given an XSL tag name, return an integer token that corresponds to the enums defined above...
XalanArrayAllocator< const void * > PointerVectorAllocatorType
#define XALAN_XSLT_EXPORT
virtual const XalanMatchPatternData * createXalanMatchPatternData(const ElemTemplate &theTemplate, size_type thePosition, const XalanDOMString &theTargetString, const XPath &theMatchPattern, const XalanDOMString &thePatternString, XPath::eMatchScore thePriority)=0
Create an instance of XalanMatchPatternData, which describes data related to a match pattern and temp...
XalanDOMString::size_type length(const XalanDOMString &theString)
Get the length of a XalanDOMString.
XERCES_CPP_NAMESPACE_QUALIFIER AttributeList AttributeListType
XalanArrayAllocator< XalanDOMChar > XalanDOMCharVectorAllocatorType
virtual const AVTPart * createAVTPart(const XalanDOMChar *theString, XalanDOMString::size_type theLength=XalanDOMString::npos)=0
Create an AVTPart instance.
This class represents the base stylesheet or an "import" stylesheet.
Definition: Stylesheet.hpp:86
virtual double getXSLTVersionSupported() const =0
Get the latest XSLT version currently supported.
Class to represent a qualified name.
Definition: XalanQName.hpp:70
virtual bool isXMLSpaceAttribute(const XalanDOMChar *theAttributeName, const Stylesheet &theStylesheet, const Locator *theLocator=0)=0
Given an name, determine if it is the xml:space attribute.
Xalan implementation of deque.
Definition: XalanDeque.hpp:200
An default implementation of an abtract class which provides support for constructing the internal re...

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