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
49namespace 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
60namespace XALAN_CPP_NAMESPACE {
61
62
63
64class XercesDOMSupport;
65#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
66class XercesDocumentBridge;
67#endif
68class XercesDocumentWrapper;
69
70
71typedef xercesc::SAXParseException SAXParseExceptionType;
72
73
75 public XMLParserLiaison,
76 public ErrorHandler
77{
78
79public:
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 */
92 MemoryManager& theManager XALAN_DEFAULT_MEMMGR);
93
94 /**
95 * Construct a XercesParserLiaison instance.
96 */
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
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
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
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
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
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
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(
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 */
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 */
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 */
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 */
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*
452
453 // Implementations for SAX ErrorHandler
454
455 virtual void
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
480 {
481 return false;
482 }
483#endif
484
486
487 bool
488 isOwned() const
489 {
490 return m_isOwned;
491 }
492
493#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
494 union
495 {
497 XercesDocumentWrapper* m_wrapper;
498 };
499
500 DocumentEntry&
502 {
503 m_isDeprecated = true;
504
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
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
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
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
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
674 {
675 m_buildMaps = newState;
676 }
677
678 typedef xercesc::XercesDOMParser DOMParserType;
679
680protected:
681
682 static void
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(
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 */
717 bool threadSafe,
718 bool buildWrapper,
719 bool buildMaps,
720 bool isOwned);
721
722private:
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
void setBuildBridgeNodes(bool newState)
This API is deprecated.
virtual ExecutionContext * getExecutionContext() const
Get a pointer to the current ExecutionContext instance, which may be null.
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.
XalanDocument * createDocument(const DOMDocument_Type *theXercesDocument)
Create a XalanDocument proxy for an existing Xerces document.
virtual DOMDocument_Type * createDOMFactory()
Create an instance of the Xerces default document that is suitable as a raw document.
virtual const XalanDOMChar * getExternalSchemaLocation() const
This method returns the location for an external schema document for parsing.
virtual void fatalError(const SAXParseExceptionType &exception)
bool getThreadSafe() const
This functions returns the state of the liaison's thread-safe flag.
virtual ErrorHandler * getErrorHandler() const
This method returns the installed error handler.
XercesParserLiaison(MemoryManager &theManager XALAN_DEFAULT_MEMMGR)
Construct a XercesParserLiaison instance.
const DOMDocument_Type * mapToXercesDocument(const XalanDocument *theDocument) const
Map a pointer to a XalanDocument instance to its corresponding class pointer.
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 void setExitOnFirstFatalError(bool newState)
This method allows users to set the parser's behaviour when it encounters the first fatal error.
virtual EntityResolver * getEntityResolver() const
This method returns the installed EntityResolver.
virtual void setDoNamespaces(bool newState)
This method allows users to enable or disable the parser's namespace processing.
xercesc::XercesDOMParser DOMParserType
XercesDocumentWrapper * doCreateDocument(const DOMDocument_Type *theXercesDocument, bool threadSafe, bool buildWrapper, bool buildMaps, bool isOwned)
Create a XalanDocument proxy for an existing Xerces document.
XercesParserLiaison(XercesDOMSupport &theSupport, MemoryManager &theManager XALAN_DEFAULT_MEMMGR)
Construct a XercesParserLiaison instance.
virtual bool getIncludeIgnorableWhitespace() const
Get the 'include ignorable whitespace' flag.
MemoryManager & getMemoryManager()
Get a reference to the current MemoryManager instance.
virtual bool getDoNamespaces() const
This method returns the state of the parser's namespace handling capability.
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 const XalanDOMChar * getExternalNoNamespaceSchemaLocation() const
This method returns the location for an external schema document for parsing.
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.
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 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().
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 XMLEntityResolver * getXMLEntityResolver() const
This method returns the installed XMLEntityResolver.
XalanDocument * createDocument(const DOMDocument_Type *theXercesDocument, bool threadSafe, bool buildWrapper, bool buildMaps=false)
Create a XalanDocument proxy for an existing Xerces document.
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 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".
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.
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)