Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

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

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