Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


XercesParserLiaison.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(XercesPARSERLIAISON_HEADER_GUARD_1357924680)
19 #define XercesPARSERLIAISON_HEADER_GUARD_1357924680
20 
21 
22 // Base include file. Must be first.
24 
25 
26 
27 // Standard Library header files.
29 
30 
31 
32 // Xerces DOM header files
33 #include <xercesc/sax/ErrorHandler.hpp>
34 
35 
36 
37 // Base class header file.
39 
40 
41 
42 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
44 #endif
46 
47 
48 
49 #if XERCES_VERSION_MAJOR >= 2
50 XALAN_DECLARE_XERCES_CLASS(XercesDOMParser)
51 #else
52 XALAN_DECLARE_XERCES_CLASS(DOMParser)
53 #endif
54 XALAN_DECLARE_XERCES_CLASS(SAXParser)
55 
56 
57 
58 XALAN_CPP_NAMESPACE_BEGIN
59 
60 
61 
62 class XercesDOMSupport;
63 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
65 #endif
67 
68 
69 typedef XERCES_CPP_NAMESPACE_QUALIFIER SAXParseException SAXParseExceptionType;
70 
71 
73  public XMLParserLiaison,
74  public ErrorHandler
75 {
76 
77 public:
78 
79  typedef XERCES_CPP_NAMESPACE_QUALIFIER SAXParser SAXParserType;
80 
81  /**
82  * Construct a XercesParserLiaison instance.
83  *
84  * @param theSupport instance of DOMSupport object
85  *
86  * @deprecated This constructor is deprecated. Use the next constructor instead.
87  */
89  XercesDOMSupport& theSupport,
90  MemoryManager& theManager XALAN_DEFAULT_MEMMGR);
91 
92  /**
93  * Construct a XercesParserLiaison instance.
94  */
95  XercesParserLiaison(MemoryManager& theManager XALAN_DEFAULT_MEMMGR);
96 
97  virtual
99 
100 
101 
102  // These interfaces are inherited from XMLParserLiaison...
103  MemoryManager&
105  {
106  return m_externalSchemaLocation.getMemoryManager();
107  }
108 
109  virtual void
110  reset();
111 
112  virtual ExecutionContext*
113  getExecutionContext() const;
114 
115  virtual void
117 
118  virtual XalanDocument*
120  const InputSource& reader,
122 
123  virtual void
125  const InputSource& urlInputSource,
126  DocumentHandler& handler,
128 
129  virtual void
130  destroyDocument(XalanDocument* theDocument);
131 
132  virtual int
133  getIndent() const;
134 
135  virtual void
136  setIndent(int i);
137 
138  virtual bool
139  getUseValidation() const;
140 
141  virtual void
142  setUseValidation(bool b);
143 
144  virtual const XalanDOMString&
145  getParserDescription(XalanDOMString& theResult) const;
146 
147  virtual EntityResolver*
148  getEntityResolver() const;
149 
150  virtual void
151  setEntityResolver(EntityResolver* resolver);
152 
153  virtual XMLEntityResolver*
154  getXMLEntityResolver() const;
155 
156  virtual void
157  setXMLEntityResolver(XMLEntityResolver* resolver);
158 
159  virtual ErrorHandler*
160  getErrorHandler() const;
161 
162  virtual void
163  setErrorHandler(ErrorHandler* handler);
164 
165  // These interfaces are new to XercesParserLiaison...
166 
167  /**
168  * Create an instance of the Xerces default document that
169  * is suitable as a raw document. The new document instance
170  * is owned by this instance and will be destroyed when this
171  * instance goes out of scope, or by an explicit call to
172  * destroyDocument()
173  *
174  * @return a pointer to the new instance
175  */
176  virtual DOMDocument_Type*
177  createDOMFactory();
178 
179  /**
180  * Destroy an instance created by a call to createDOMFactory().
181  *
182  * @theDocument a pointer to the instance to be destroyed
183  */
184  virtual void
185  destroyDocument(DOMDocument_Type* theDocument);
186 
187  /** Get the 'include ignorable whitespace' flag.
188  *
189  * This method returns the state of the parser's include ignorable
190  * whitespace flag.
191  *
192  * @return 'true' if the include ignorable whitespace flag is set on
193  * the parser, 'false' otherwise.
194  *
195  * @see #setIncludeIgnorableWhitespace
196  */
197  virtual bool
198  getIncludeIgnorableWhitespace() const;
199 
200  /** Set the 'include ignorable whitespace' flag
201  *
202  * This method allows the user to specify whether a validating parser
203  * should include ignorable whitespaces as text nodes. It has no effect
204  * on non-validating parsers which always include non-markup text.
205  * <p>When set to true (also the default), ignorable whitespaces will be
206  * added to the DOM tree as text nodes. The method
207  * <code>DOMText::isWhitespace</code> will return true for those text
208  * nodes only.
209  * <p>When set to false, all ignorable whitespace will be discarded and
210  * no text node is added to the DOM tree. Note: applications intended
211  * to process the "xml:space" attribute should not set this flag to false.
212  *
213  * @param include The new state of the include ignorable whitespace
214  * flag.
215  *
216  * @see #getIncludeIgnorableWhitespace
217  */
218  virtual void
219  setIncludeIgnorableWhitespace(bool include);
220 
221  /**
222  * This method returns the state of the parser's namespace
223  * handling capability.
224  *
225  * @return true, if the parser is currently configured to
226  * understand namespaces, false otherwise.
227  *
228  * @see #setDoNamespaces
229  */
230  virtual bool
231  getDoNamespaces() const;
232 
233  /**
234  * This method allows users to enable or disable the parser's
235  * namespace processing. When set to true, parser starts enforcing
236  * all the constraints / rules specified by the NameSpace
237  * specification.
238  *
239  * <p>The parser's default state is: false.</p>
240  *
241  * <p>This flag is ignored by the underlying scanner if the installed
242  * validator indicates that namespace constraints should be
243  * enforced.</p>
244  *
245  * @param newState The value specifying whether NameSpace rules should
246  * be enforced or not.
247  *
248  * @see #getDoNamespaces
249  */
250  virtual void
251  setDoNamespaces(bool newState);
252 
253  /**
254  * This method returns the state of the parser's
255  * exit-on-First-Fatal-Error flag.
256  *
257  * @return true, if the parser is currently configured to
258  * exit on the first fatal error, false otherwise.
259  *
260  * @see #setExitOnFirstFatalError
261  */
262  virtual bool
263  getExitOnFirstFatalError() const;
264 
265  /**
266  * This method allows users to set the parser's behaviour when it
267  * encounters the first fatal error. If set to true, the parser
268  * will exit at the first fatal error. If false, then it will
269  * report the error and continue processing.
270  *
271  * <p>The default value is 'true' and the parser exits on the
272  * first fatal error.</p>
273  *
274  * @param newState The value specifying whether the parser should
275  * continue or exit when it encounters the first
276  * fatal error.
277  *
278  * @see #getExitOnFirstFatalError
279  */
280  virtual void
281  setExitOnFirstFatalError(bool newState);
282 
283  /**
284  * This method returns the location for an external schema document
285  * for parsing.
286  *
287  * @return A string representing the location of the external schema document
288  */
289  virtual const XalanDOMChar*
290  getExternalSchemaLocation() const;
291 
292  /**
293  * This method sets the location for an external schema document
294  * for parsing.
295  *
296  * @param location A string representing the location of the external schema document
297  */
298  virtual void
299  setExternalSchemaLocation(const XalanDOMChar* location);
300 
301  /**
302  * This method returns the location for an external schema document
303  * for parsing.
304  *
305  * @return A string representing the location of the external schema document
306  */
307  virtual const XalanDOMChar*
308  getExternalNoNamespaceSchemaLocation() const;
309 
310  /**
311  * This method sets the location for an external schema document
312  * for parsing.
313  *
314  * @param location A string representing the location of the external schema document
315  */
316  virtual void
317  setExternalNoNamespaceSchemaLocation(const XalanDOMChar* location);
318 
319 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
320  /**
321  * This API is deprecated.
322  *
323  * Create a XalanDocument proxy for an existing Xerces document.
324  * The parser liaison owns the instance, and you must not delete
325  * it. The liaison will delete it when reset() is called, or the
326  * liaison is destroyed.
327  *
328  * @deprecated The Xerces DOM bridge is deprecated.
329  * @param theXercesDocument The Xerces document.
330  * @return a pointer to a new XalanDocument-derived instance.
331  */
333  createDocument(const DOM_Document_Type& theXercesDocument)
334  {
335  return createDocument(theXercesDocument, m_threadSafe, m_buildBridge);
336  }
337 
338  /**
339  * This API is deprecated.
340  *
341  * Create a XalanDocument proxy for an existing Xerces document.
342  * The parser liaison owns the instance, and you must not delete
343  * it. The liaison will delete it when reset() is called, or the
344  * liaison is destroyed.
345  *
346  * @deprecated The Xerces DOM bridge is deprecated.
347  * @param theXercesDocument The Xerces document.
348  * @param threadSafe If true, read access to the tree will be thread-safe (implies buildBridge == true).
349  * @param buildBridge If true, the entire bridge structure is built.
350  * @return a pointer to a new XalanDocument-derived instance.
351  */
353  createDocument(
354  const DOM_Document_Type& theXercesDocument,
355  bool threadSafe,
356  bool buildBridge);
357 #endif
358 
359  /**
360  * Create a XalanDocument proxy for an existing Xerces document.
361  * The parser liaison owns the instance, and you must not delete
362  * it. The liaison will delete it when reset() is called, or the
363  * liaison is destroyed.
364  *
365  * @param theXercesDocument The Xerces document.
366  * @return a pointer to a new XalanDocument-derived instance.
367  */
369  createDocument(const DOMDocument_Type* theXercesDocument)
370  {
371  return createDocument(theXercesDocument, m_threadSafe, m_buildWrapper, m_buildMaps);
372  }
373 
374  /**
375  * Create a XalanDocument proxy for an existing Xerces document.
376  * The parser liaison owns the instance, and you must not delete
377  * it. The liaison will delete it when reset() is called, or the
378  * liaison is destroyed.
379  *
380  * @param theXercesDocument The Xerces document.
381  * @param threadSafe If true, read access to the tree will be thread-safe (implies buildWrapper == true).
382  * @param buildWrapper If true, the entire wrapper structure is built.
383  * @param buildMaps If true, the map of Xerces to Xalan nodes is always built.
384  * @return a pointer to a new XalanDocument-derived instance.
385  */
387  createDocument(
388  const DOMDocument_Type* theXercesDocument,
389  bool threadSafe,
390  bool buildWrapper,
391  bool buildMaps = false);
392 
393 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
394  /**
395  * This API is deprecated.
396  *
397  * Map a pointer to a XalanDocument instance to its implementation
398  * class pointer. Normally, you should have no reason for doing
399  * this. The liaison will return a null pointer if it did not
400  * create the instance passed.
401  *
402  * @deprecated The Xerces DOM bridge has been deprecated.
403  * @param theDocument A pointer to a XalanDocument instance.
404  * @return A pointer to the XercesDocumentBridge instance.
405  */
407  mapDocument(const XalanDocument* theDocument) const;
408 #endif
409 
410  /**
411  * Map a pointer to a XalanDocument instance to its implementation
412  * class pointer. Normally, you should have no reason for doing
413  * this. The liaison will return a null pointer if it did not
414  * create the instance passed.
415  *
416  * @param theDocument A pointer to a XalanDocument instance.
417  * @return A pointer to the XercesDocumentWrapper instance.
418  */
420  mapDocumentToWrapper(const XalanDocument* theDocument) const;
421 
422 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
423  /**
424  * This API is deprecated.
425  *
426  * Map a pointer to a XalanDocument instance to its corresponding
427  * class pointer. Normally, you should have no reason for doing
428  * this. The liaison will return a null pointer if it did not
429  * create the instance passed.
430  *
431  * @deprecated The Xerces DOM bridge has been deprecated.
432  * @param theDocument A pointer to a XalanDocument instance.
433  * @return A pointer to the XercesDocumentBridge instance.
434  */
436  mapXercesDocument(const XalanDocument* theDocument) const;
437 #endif
438 
439  /**
440  * Map a pointer to a XalanDocument instance to its corresponding
441  * class pointer. Normally, you should have no reason for doing
442  * this. The liaison will return a null pointer if it did not
443  * create the instance passed.
444  *
445  * @param theDocument A pointer to a XalanDocument instance.
446  * @return A pointer to the XercesDocumentBridge instance.
447  */
448  const DOMDocument_Type*
449  mapToXercesDocument(const XalanDocument* theDocument) const;
450 
451  // Implementations for SAX ErrorHandler
452 
453  virtual void
454  warning(const SAXParseExceptionType& exception);
455 
456  virtual void
457  error(const SAXParseExceptionType& exception);
458 
459  virtual void
460  fatalError(const SAXParseExceptionType& exception);
461 
462  virtual void
463  resetErrors();
464 
466  {
467 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
468  bool m_isDeprecated;
469 
470  bool
471  isDeprecated() const
472  {
473  return m_isDeprecated;
474  }
475 #else
476  bool
477  isDeprecated() const
478  {
479  return false;
480  }
481 #endif
482 
483  bool m_isOwned;
484 
485  bool
486  isOwned() const
487  {
488  return m_isOwned;
489  }
490 
491 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
492  union
493  {
494  XercesDocumentBridge* m_bridge;
495  XercesDocumentWrapper* m_wrapper;
496  };
497 
498  DocumentEntry&
499  operator=(XercesDocumentBridge* theBridge)
500  {
501  m_isDeprecated = true;
502 
503  m_bridge = theBridge;
504 
505  m_isOwned = true;
506 
507  return *this;
508  }
509 
510  DocumentEntry&
511  operator=(XercesDocumentWrapper* theWrapper)
512  {
513  m_isDeprecated = false;
514 
515  m_wrapper = theWrapper;
516 
517  m_isOwned = true;
518 
519  return *this;
520  }
521 #else
523 
526  {
527  m_wrapper = theWrapper;
528 
529  m_isOwned = true;
530 
531  return *this;
532  }
533 #endif
534  };
535 
537 
538  /**
539  * This API is deprecated.
540  *
541  * This functions returns the state of the liaison's build-bridge-nodes flag.
542  *
543  * @deprecated The Xerces DOM bridge is deprecated.
544  * @return true, if the bridge nodes are automatically built, false otherwise.
545  */
546  bool
548 
549  {
550  return m_buildBridge;
551  }
552 
553  /**
554  * This API is deprecated.
555  *
556  * This functions sets the state of the liaison's build-bridge-nodes flag.
557  * This flag must be set for the document to be thread safe. It can also be
558  * set to true to increase performance. If this flag is set to false, then
559  * the thread-safe flag will also be set to false.
560  *
561  * @deprecated The Xerces DOM bridge is deprecated.
562  * @param newState The new state for the flag.
563  *
564  */
565  void
566  setBuildBridgeNodes(bool newState)
567  {
568  m_buildBridge = newState;
569 
570  if (newState == false)
571  {
572  m_threadSafe = false;
573  }
574  }
575 
576  /**
577  * This functions returns the state of the liaison's build-wrapper-nodes flag.
578  *
579  * @return true, if the wrapper nodes are automatically built, false otherwise.
580  */
581  bool
583 
584  {
585  return m_buildWrapper;
586  }
587 
588  /**
589  * This functions sets the state of the liaison's build-wrapper-nodes flag.
590  * This flag must be set for the document to be thread safe. It can also be
591  * set to true to increase performance. If this flag is set to false, then
592  * the thread-safe flag will also be set to false.
593  *
594  * @param newState The new state for the flag.
595  *
596  */
597  void
598  setBuildWrapperNodes(bool newState)
599  {
600  m_buildWrapper = newState;
601 
602  if (newState == false)
603  {
604  m_threadSafe = false;
605  }
606  }
607 
608  /**
609  * This functions returns the state of the liaison's thread-safe flag.
610  * If true, documents created will be safe when data is read. By default,
611  * documents are _not_ thread-safe.
612  *
613  * Note -- modifications are _never_ synchronized.
614  *
615  * @return true, if the new documents will be thread safe, false otherwise.
616  */
617  bool
619 
620  {
621  return m_threadSafe;
622  }
623 
624  /**
625  * This functions sets the state of the liaison's thread-safe flag.
626  * This flag must be set for the document to be thread safe. If this
627  * flag is set to true, then the build-bridge-nodes flag will also be
628  * set to true.
629  *
630  * @param newState The new state for the flag.
631  *
632  */
633  void
634  setThreadSafe(bool newState)
635  {
636  m_threadSafe = newState;
637 
638  if (m_threadSafe == true)
639  {
640  m_buildWrapper = true;
641  m_buildBridge = true;
642  }
643  }
644 
645  /**
646  * This functions returns the state of the liaison's buildMaps flag.
647  * If true, maps will be created to allow mapping of Xalan<->Xerces mapping
648  * in both directions for XercesWrapper classes.
649  *
650  * @return true, if the new documents will be built with Maps
651  */
652  bool
653  getBuildMaps() const
654 
655  {
656  return m_buildMaps;
657  }
658 
659  /**
660  * This functions sets the state of the liaison's buildMaps flag.
661  * When this flag is true, maps will be built providing Xerces<->Xalan
662  * mapping in Wrapper classes.
663  *
664  * @note The maps created use a large amount of memory. If only
665  * Xalan->Xerces node mapping is required, do not set this to true.
666  *
667  * @param newState The new state for the flag.
668  *
669  */
670  void
671  setBuildMaps(bool newState)
672  {
673  m_buildMaps = newState;
674  }
675 
676  typedef XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser DOMParserType;
677 
678 protected:
679 
680  static void
681  formatErrorMessage(
682  const SAXParseExceptionType& e,
683  XalanDOMString& theMessage);
684 
685 #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
686  /**
687  * Create a XalanDocument proxy for an existing Xerces document.
688  *
689  * This API is deprecated.
690  *
691  * @param theXercesDocument The Xerces document.
692  * @param threadSafe If true, read access to the tree will be thread-safe (implies buildBridge == true).
693  * @param buildBridge If true, the entire bridge structure is built.
694  * @return a pointer to a new XercesDocumentBridge instance.
695  */
697  doCreateDocument(
698  const DOM_Document_Type& theXercesDocument,
699  bool threadSafe,
700  bool buildBridge);
701 #endif
702 
703  /**
704  * Create a XalanDocument proxy for an existing Xerces document.
705  *
706  * @param theXercesDocument The Xerces document.
707  * @param threadSafe If true, read access to the tree will be thread-safe (implies buildBridge == true).
708  * @param buildWrapper If true, the entire bridge structure is built.
709  * @param buildMaps If true, the map of Xerces to Xalan nodes is always built.
710  * @return a pointer to a new XercesDocumentWrapper instance.
711  */
713  doCreateDocument(
714  const DOMDocument_Type* theXercesDocument,
715  bool threadSafe,
716  bool buildWrapper,
717  bool buildMaps,
718  bool isOwned);
719 
720 private:
721 
722  void
723  ensureDOMParser();
724 
725  DOMParserType*
726  createDOMParser();
727 
728  SAXParserType*
729  createSAXParser();
730 
731 
732 
733  // Data members...
734  int m_indent;
735 
736  bool m_useValidation;
737 
738  bool m_includeIgnorableWhitespace;
739 
740  bool m_doNamespaces;
741 
742  bool m_exitOnFirstFatalError;
743 
744  EntityResolver* m_entityResolver;
745 
746  XMLEntityResolver* m_xmlEntityResolver;
747 
748  ErrorHandler* m_errorHandler;
749 
750  XalanDOMString m_externalSchemaLocation;
751 
752  XalanDOMString m_externalNoNamespaceSchemaLocation;
753 
754  DocumentMapType m_documentMap;
755 
756  bool m_buildWrapper;
757 
758  bool m_buildBridge;
759 
760  bool m_threadSafe;
761 
762  bool m_buildMaps;
763 
764  ExecutionContext* m_executionContext;
765 
766  DOMParserType* m_domParser;
767 };
768 
769 
770 
771 XALAN_CPP_NAMESPACE_END
772 
773 
774 
775 #endif // XercesPARSERLIAISON_HEADER_GUARD_1357924680
void setBuildBridgeNodes(bool newState)
This API is deprecated.
virtual void setXMLEntityResolver(XMLEntityResolver *resolver)=0
This method installs the user-specified XMLEntityResolver on the parser.
bool getBuildMaps() const
This functions returns the state of the liaison's buildMaps flag.
This class is deprecated.
void setThreadSafe(bool newState)
This functions sets the state of the liaison's thread-safe flag.
virtual int getIndent() const =0
Get the amount to indent when indent-result="yes".
virtual EntityResolver * getEntityResolver() const =0
This method returns the installed EntityResolver.
XERCES_CPP_NAMESPACE_QUALIFIER SAXParseException SAXParseExceptionType
void setBuildMaps(bool newState)
This functions sets the state of the liaison's buildMaps flag.
#define XALAN_XERCESPARSERLIAISON_EXPORT
DocumentEntry & operator=(XercesDocumentWrapper *theWrapper)
MemoryManager & getMemoryManager()
Get a reference to the current MemoryManager instance.
XalanMap< const XalanDocument *, DocumentEntry > DocumentMapType
virtual ErrorHandler * getErrorHandler() const =0
This method returns the installed error handler.
bool getThreadSafe() const
This functions returns the state of the liaison's thread-safe flag.
void setBuildWrapperNodes(bool newState)
This functions sets the state of the liaison's build-wrapper-nodes flag.
virtual XalanDocument * parseXMLStream(const InputSource &inputSource, const XalanDOMString &identifier)=0
Parse the text pointed at by the reader as XML, and return a DOM Document interface.
virtual XMLEntityResolver * getXMLEntityResolver() const =0
This method returns the installed XMLEntityResolver.
#define XALAN_DEFAULT_MEMMGR
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument DOMDocument_Type
virtual const XalanDOMString & getParserDescription(XalanDOMString &theResult) const =0
Return a string suitable for telling the user what parser is being used.
static MemoryManager & getDummyMemMgr()
XERCES_CPP_NAMESPACE_QUALIFIER DOM_Document DOM_Document_Type
XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser DOMParserType
virtual void setUseValidation(bool b)=0
If set to true, validation will be performed.
bool getBuildBridgeNodes() const
This API is deprecated.
virtual void setEntityResolver(EntityResolver *resolver)=0
This method installs the user-specified EntityResolver on the parser.
virtual void setErrorHandler(ErrorHandler *handler)=0
This method installs the user-specified error handler.
virtual ExecutionContext * getExecutionContext() const =0
Get a pointer to the current ExecutionContext instance, which may be null.
XalanDocument * createDocument(const DOMDocument_Type *theXercesDocument)
Create a XalanDocument proxy for an existing Xerces document.
virtual void setIndent(int i)=0
Set the amount to indent when indent-result="yes".
virtual void reset()=0
Reset the instance, freeing any XalanDocument instances created through parseXMLStream().
virtual void destroyDocument(XalanDocument *theDocument)=0
Destroy the supplied XalanDocument instance.
bool getBuildWrapperNodes() const
This functions returns the state of the liaison's build-wrapper-nodes flag.
virtual void setExecutionContext(ExecutionContext &theContext)=0
Set the current ExecutionContext instance.
virtual bool getUseValidation() const =0
Get whether or not validation will be performed.
XERCES_CPP_NAMESPACE_QUALIFIER SAXParser SAXParserType

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