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