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 
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 
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.
This class is deprecated.
void setThreadSafe(bool newState)
This functions sets the state of the liaison&#39;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&#39;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.
void setBuildWrapperNodes(bool newState)
This functions sets the state of the liaison&#39;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.
bool getBuildBridgeNodes() const
This API is deprecated.
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.
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 getBuildMaps() const
This functions returns the state of the liaison&#39;s buildMaps flag.
virtual void setExecutionContext(ExecutionContext &theContext)=0
Set the current ExecutionContext instance.
bool getThreadSafe() const
This functions returns the state of the liaison&#39;s thread-safe flag.
virtual bool getUseValidation() const =0
Get whether or not validation will be performed.
XERCES_CPP_NAMESPACE_QUALIFIER SAXParser SAXParserType
bool getBuildWrapperNodes() const
This functions returns the state of the liaison&#39;s build-wrapper-nodes flag.

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