doc/program-sax.xml - xerces-c - Git at Google

 <?xml version="1.0" standalone="no"?>
 <!DOCTYPE s1 SYSTEM "sbk:/style/dtd/document.dtd">

 <s1 title="SAX1 Programming Guide">

     <anchor name="UsingSAX1API"/>
     <s2 title="Using the SAX API">
       <p>The SAX API for XML parsers was originally developed for
         Java.  Please be aware that there is no standard SAX API for
         C++, and that use of the &XercesCName; SAX API does not
         guarantee client code compatibility with other C++ XML
         parsers.</p>

       <p>The SAX API presents a callback based API to the parser. An
         application that uses SAX provides an instance of a handler
         class to the parser. When the parser detects XML constructs,
         it calls the methods of the handler class, passing them
         information about the construct that was detected. The most
         commonly used handler classes are DocumentHandler which is
         called when XML constructs are recognized, and ErrorHandler
         which is called when an error occurs. The header files for the
         various SAX handler classes are in
         '&lt;&XercesCInstallDir;>/include/xercesc/sax'</p>

       <p>As a convenience, &XercesCName; provides the class
         HandlerBase, which is a single class which is publicly derived
         from all the Handler classes. HandlerBase's default
         implementation of the handler callback methods is to do
         nothing. A convenient way to get started with &XercesCName; is
         to derive your own handler class from HandlerBase and override
         just those methods in HandlerBase which you are interested in
         customizing. This simple example shows how to create a handler
         which will print element names, and print fatal error
         messages. The source code for the sample applications show
         additional examples of how to write handler classes.</p>

       <p>This is the header file MySAXHandler.hpp:</p>
 <source>#include &lt;xercesc/sax/HandlerBase.hpp>

 class MySAXHandler : public HandlerBase {
 public:
     void startElement(const XMLCh* const, AttributeList&amp;);
     void fatalError(const SAXParseException&amp;);
 };</source>

       <p>This is the implementation file MySAXHandler.cpp:</p>

 <source>#include "MySAXHandler.hpp"
 #include &lt;iostream.h>

 MySAXHandler::MySAXHandler()
 {
 }

 MySAXHandler::startElement(const XMLCh* const name,
                            AttributeList&amp; attributes)
 {
     char* message = XMLString::transcode(name);
     cout &lt;&lt; "I saw element: "&lt;&lt; message &lt;&lt; endl;
     delete [] message;
 }

 MySAXHandler::fatalError(const SAXParseException&amp; exception)
 {
     char* message = XMLString::transcode(exception.getMessage());
     cout &lt;&lt; "Fatal Error: " &lt;&lt; message
          &lt;&lt; " at line: " &lt;&lt; exception.getLineNumber()
          &lt;&lt; endl;
 }</source>

       <p>The XMLCh and AttributeList types are supplied by
         &XercesCName; and are documented in the include
         files. Examples of their usage appear in the source code to
         the sample applications.</p>
     </s2>

     <anchor name="SAXParser"/>
     <s2 title="SAXParser">
         <anchor name="ConstructParser"/>
         <s3 title="Constructing a SAXParser">
           <p>In order to use &XercesCName; to parse XML files, you will
             need to create an instance of the SAXParser class. The example
             below shows the code you need in order to create an instance
             of SAXParser. The DocumentHandler and ErrorHandler instances
             required by the SAX API are provided using the HandlerBase
             class supplied with &XercesCName;.</p>

     <source>
     #include &lt;xercesc/parsers/SAXParser.hpp>
     #include &lt;xercesc/sax/HandlerBase.hpp>
     #include &lt;xercesc/util/XMLString.hpp>

     int main (int argc, char* args[]) {

         try {
             XMLPlatformUtils::Initialize();
         }
         catch (const XMLException&amp; toCatch) {
             char* message = XMLString::transcode(toCatch.getMessage());
             cout &lt;&lt; "Error during initialization! :\n"
                  &lt;&lt; message &lt;&lt; "\n";
             delete [] message;
             return 1;
         }

         char* xmlFile = "x1.xml";
         SAXParser* parser = new SAXParser();
         parser->setDoValidation(true);    // optional.
         parser->setDoNamespaces(true);    // optional

         DocumentHandler* docHandler = new HandlerBase();
         ErrorHandler* errHandler = (ErrorHandler*) docHandler;
         parser->setDocumentHandler(docHandler);
         parser->setErrorHandler(errHandler);

         try {
             parser->parse(xmlFile);
         }
         catch (const XMLException&amp; toCatch) {
             char* message = XMLString::transcode(toCatch.getMessage());
             cout &lt;&lt; "Exception message is: \n"
                  &lt;&lt; message &lt;&lt; "\n";
             delete [] message;
             return -1;
         }
         catch (const SAXParseException&amp; toCatch) {
             char* message = XMLString::transcode(toCatch.getMessage());
             cout &lt;&lt; "Exception message is: \n"
                  &lt;&lt; message &lt;&lt; "\n";
             delete [] message;
             return -1;
         }
         catch (...) {
             cout &lt;&lt; "Unexpected Exception \n" ;
             return -1;
         }

         delete parser;
         delete docHandler;
         return 0;
     }</source>
         </s3>

         <anchor name="SAXFeatures"/>
         <s3 title="SAXParser Supported Features">

            <p>The behavior of the SAXParser is dependant on the values of the following features.  All
            of the features below are set using the "setter" methods (e.g. <code>setDoNamespaces</code>),
            and are queried using the corresponding "getter" methods (e.g. <code>getDoNamespaces</code>).
            The following only gives you a quick summary of supported features.  Please
            refer to <jump href="api.html">API Documentataion</jump> for complete detail.
            </p>
            <p>None of these features can be modified in the middle of a parse, or an exception will be thrown.</p>


             <anchor name="namespaces"/>
             <table>
                 <tr><th colspan="2"><em>void setDoNamespaces(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> Perform Namespace processing. </td></tr>
                 <tr><th><em>false:</em></th><td> Do not perform Namespace processing. </td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note:</em></th><td> If the validation scheme is set to Val_Always or Val_Auto, then the
                 document must contain a grammar that supports the use of namespaces. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="validation-dynamic">setValidationScheme</link>
                 </td></tr>
             </table>
             <p/>

             <anchor name="validation"/>
             <table>
                 <tr><th colspan="2"><em>void setDoValidation(const bool)</em> (deprecated) <br/>
                 please use <link anchor="validation-dynamic">setValidationScheme</link>.
                 </th></tr>
                 <tr><th><em>true:</em></th><td> Report all validation errors. </td></tr>
                 <tr><th><em>false:</em></th><td> Do not report validation errors. </td></tr>
                 <tr><th><em>default:</em></th><td> see the default of
                 <link anchor="validation-dynamic">setValidationScheme</link>.
                 </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="validation-dynamic">setValidationScheme</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="validation-dynamic"/>
             <table>
                 <tr><th colspan="2"><em>void setValidationScheme(const ValSchemes)</em></th></tr>
                 <tr><th><em>Val_Auto:</em></th><td> The parser will report validation errors only if a grammar is specified. </td></tr>
                 <tr><th><em>Val_Always:</em></th><td> The parser will always report validation errors. </td></tr>
                 <tr><th><em>Val_Never:</em></th><td> Do not report validation errors. </td></tr>
                 <tr><th><em>default:</em></th><td> Val_Auto </td></tr>
                 <tr><th><em>note:</em></th><td> If set to Val_Always, the document must
                 specify a grammar.  If this feature is set to Val_Never and document specifies a grammar,
                 that grammar might be parsed but no validation of the document contents will be
                 performed. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="load-external-dtd">setLoadExternalDTD</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="schema"/>
             <table>
                 <tr><th colspan="2"><em>void setDoSchema(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> Enable the parser's schema support.  </td></tr>
                 <tr><th><em>false:</em></th><td> Disable the parser's schema support. </td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note</em></th><td> If set to true, namespace processing must also be turned on. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="namespaces">setDoNamespaces</link>
                 </td></tr>
             </table>

             <p/>

             <table>
                 <tr><th colspan="2"><em>void setValidationSchemaFullChecking(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> Enable full schema constraint checking, including checking
                              which may be time-consuming or memory intensive. Currently, particle unique
                              attribution constraint checking and particle derivation restriction checking
                              are controlled by this option. </td></tr>
                 <tr><th><em>false:</em></th><td> Disable full schema constraint checking. </td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note:</em></th><td> This feature checks the Schema grammar itself for
                 additional errors that are time-consuming or memory intensive. It does <em>not</em> affect the
                 level of checking performed on document instances that use Schema grammars. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="schema">setDoSchema</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="load-external-dtd"/>
             <table>
                 <tr><th colspan="2"><em>void setLoadExternalDTD(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> Load the External DTD . </td></tr>
                 <tr><th><em>false:</em></th><td> Ignore the external DTD completely. </td></tr>
                 <tr><th><em>default:</em></th><td> true </td></tr>
                 <tr><th><em>note</em></th><td> This feature is ignored and DTD is always loaded
                 if the validation scheme is set to Val_Always or Val_Auto. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="validation-dynamic">setValidationScheme</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="continue-after-fatal"/>
             <table>
                 <tr><th colspan="2"><em>void setExitOnFirstFatalError(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> Stops parse on first fatal error. </td></tr>
                 <tr><th><em>false:</em></th><td> Attempt to continue parsing after a fatal error. </td></tr>
                 <tr><th><em>default:</em></th><td> true </td></tr>
                 <tr><th><em>note:</em></th><td> The behavior of the parser when this feature is set to
                 false is <em>undetermined</em>! Therefore use this feature with extreme caution because
                 the parser may get stuck in an infinite loop or worse. </td></tr>
             </table>

             <p/>

             <table>
                 <tr><th colspan="2"><em>void setValidationConstraintFatal(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td> The parser will treat validation error as fatal and will
                 exit depends on the state of
                 <link anchor="continue-after-fatal">setExitOnFirstFatalError</link>.
                 </td></tr>
                 <tr><th><em>false:</em></th><td> The parser will report the error and continue processing. </td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note:</em></th><td> Setting this true does not mean the validation error will
                 be printed with the word "Fatal Error".   It is still printed as "Error", but the parser
                 will exit if
                 <link anchor="continue-after-fatal">setExitOnFirstFatalError</link>
                 is set to true. </td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="continue-after-fatal">setExitOnFirstFatalError</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="use-cached"/>
             <table>
                 <tr><th colspan="2"><em>void useCachedGrammarInParse(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td>Use cached grammar if it exists in the pool.</td></tr>
                 <tr><th><em>false:</em></th><td>Parse the schema grammar.</td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note:</em></th><td>The getter function for this method is called isUsingCachedGrammarInParse</td></tr>
                 <tr><th><em>note:</em></th><td>If the grammar caching option is enabled, this option is set to true automatically.
                 Any setting to this option by the users is a no-op.</td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="cache-grammar">cacheGrammarFromParse</link>
                 </td></tr>
             </table>

             <p/>

             <anchor name="cache-grammar"/>
             <table>
                 <tr><th colspan="2"><em>void cacheGrammarFromParse(const bool)</em></th></tr>
                 <tr><th><em>true:</em></th><td>Cache the grammar in the pool for re-use in subsequent parses.</td></tr>
                 <tr><th><em>false:</em></th><td>Do not cache the grammar in the pool</td></tr>
                 <tr><th><em>default:</em></th><td> false </td></tr>
                 <tr><th><em>note:</em></th><td>The getter function for this method is called isCachingGrammarFromParse</td></tr>
                 <tr><th><em>note:</em></th><td> If set to true, the useCachedGrammarInParse
                 is also set to true automatically.</td></tr>
                 <tr><th><em>see:</em></th><td>
                 <link anchor="use-cached">useCachedGrammarInParse</link>
                 </td></tr>
             </table>

             <p/>

             <table>
                 <tr><th colspan="2"><em>void setExternalSchemaLocation(const XMLCh* const)</em></th></tr>
                 <tr><th><em>Description</em></th><td> The XML Schema Recommendation explicitly states that
                             the inclusion of schemaLocation/ noNamespaceSchemaLocation attributes in the
                             instance document is only a hint; it does not mandate that these attributes
                             must be used to locate schemas.  Similar situation happens to &lt;import&gt;
                             element in schema documents. This property allows the user to specify a list
                             of schemas to use.  If the targetNamespace of a schema specified using this
                             method matches the targetNamespace of a schema occurring in the instance
                             document in schemaLocation attribute, or
                             if the targetNamespace matches the namespace attribute of &lt;import&gt;
                             element, the schema specified by the user using this property will
                             be used (i.e., the schemaLocation attribute in the instance document
                             or on the &lt;import&gt; element will be effectively ignored). </td></tr>
                 <tr><th><em>Value</em></th><td> The syntax is the same as for schemaLocation attributes
                                  in instance documents: e.g, "http://www.example.com file_name.xsd".
                                  The user can specify more than one XML Schema in the list. </td></tr>
                 <tr><th><em>Value Type</em></th><td> XMLCh* </td></tr>
             </table>

             <p/>
             <table>
                 <tr><th colspan="2"><em>void setExternalNoNamespaceSchemaLocation(const XMLCh* const)</em></th></tr>
                 <tr><th><em>Description</em></th><td> The XML Schema Recommendation explicitly states that
                             the inclusion of schemaLocation/ noNamespaceSchemaLocation attributes in the
                             instance document is only a hint; it does not mandate that these attributes
                             must be used to locate schemas.  This property allows the user to specify the
                             no target namespace XML Schema Location externally.  If specified, the instance
                             document's noNamespaceSchemaLocation attribute will be effectively ignored. </td></tr>
                 <tr><th><em>Value</em></th><td> The syntax is the same as for the noNamespaceSchemaLocation
                             attribute that may occur in an instance document: e.g."file_name.xsd". </td></tr>
                 <tr><th><em>Value Type</em></th><td> XMLCh* </td></tr>
             </table>

             <p/>

         </s3>
     </s2>

 </s1>
	<?xml version="1.0" standalone="no"?>
	<!DOCTYPE s1 SYSTEM "sbk:/style/dtd/document.dtd">

	<s1 title="SAX1 Programming Guide">

	<anchor name="UsingSAX1API"/>
	<s2 title="Using the SAX API">
	<p>The SAX API for XML parsers was originally developed for
	Java. Please be aware that there is no standard SAX API for
	C++, and that use of the &XercesCName; SAX API does not
	guarantee client code compatibility with other C++ XML
	parsers.</p>

	<p>The SAX API presents a callback based API to the parser. An
	application that uses SAX provides an instance of a handler
	class to the parser. When the parser detects XML constructs,
	it calls the methods of the handler class, passing them
	information about the construct that was detected. The most
	commonly used handler classes are DocumentHandler which is
	called when XML constructs are recognized, and ErrorHandler
	which is called when an error occurs. The header files for the
	various SAX handler classes are in
	'<&XercesCInstallDir;>/include/xercesc/sax'</p>

	<p>As a convenience, &XercesCName; provides the class
	HandlerBase, which is a single class which is publicly derived
	from all the Handler classes. HandlerBase's default
	implementation of the handler callback methods is to do
	nothing. A convenient way to get started with &XercesCName; is
	to derive your own handler class from HandlerBase and override
	just those methods in HandlerBase which you are interested in
	customizing. This simple example shows how to create a handler
	which will print element names, and print fatal error
	messages. The source code for the sample applications show
	additional examples of how to write handler classes.</p>

	<p>This is the header file MySAXHandler.hpp:</p>
	<source>#include <xercesc/sax/HandlerBase.hpp>

	class MySAXHandler : public HandlerBase {
	public:
	void startElement(const XMLCh* const, AttributeList&);
	void fatalError(const SAXParseException&);
	};</source>

	<p>This is the implementation file MySAXHandler.cpp:</p>

	<source>#include "MySAXHandler.hpp"
	#include <iostream.h>

	MySAXHandler::MySAXHandler()
	{
	}

	MySAXHandler::startElement(const XMLCh* const name,
	AttributeList& attributes)
	{
	char* message = XMLString::transcode(name);
	cout << "I saw element: "<< message << endl;
	delete [] message;
	}

	MySAXHandler::fatalError(const SAXParseException& exception)
	{
	char* message = XMLString::transcode(exception.getMessage());
	cout << "Fatal Error: " << message
	<< " at line: " << exception.getLineNumber()
	<< endl;
	}</source>

	<p>The XMLCh and AttributeList types are supplied by
	&XercesCName; and are documented in the include
	files. Examples of their usage appear in the source code to
	the sample applications.</p>
	</s2>

	<anchor name="SAXParser"/>
	<s2 title="SAXParser">
	<anchor name="ConstructParser"/>
	<s3 title="Constructing a SAXParser">
	<p>In order to use &XercesCName; to parse XML files, you will
	need to create an instance of the SAXParser class. The example
	below shows the code you need in order to create an instance
	of SAXParser. The DocumentHandler and ErrorHandler instances
	required by the SAX API are provided using the HandlerBase
	class supplied with &XercesCName;.</p>

	<source>
	#include <xercesc/parsers/SAXParser.hpp>
	#include <xercesc/sax/HandlerBase.hpp>
	#include <xercesc/util/XMLString.hpp>

	int main (int argc, char* args[]) {

	try {
	XMLPlatformUtils::Initialize();
	}
	catch (const XMLException& toCatch) {
	char* message = XMLString::transcode(toCatch.getMessage());
	cout << "Error during initialization! :\n"
	<< message << "\n";
	delete [] message;
	return 1;
	}

	char* xmlFile = "x1.xml";
	SAXParser* parser = new SAXParser();
	parser->setDoValidation(true); // optional.
	parser->setDoNamespaces(true); // optional

	DocumentHandler* docHandler = new HandlerBase();
	ErrorHandler* errHandler = (ErrorHandler*) docHandler;
	parser->setDocumentHandler(docHandler);
	parser->setErrorHandler(errHandler);

	try {
	parser->parse(xmlFile);
	}
	catch (const XMLException& toCatch) {
	char* message = XMLString::transcode(toCatch.getMessage());
	cout << "Exception message is: \n"
	<< message << "\n";
	delete [] message;
	return -1;
	}
	catch (const SAXParseException& toCatch) {
	char* message = XMLString::transcode(toCatch.getMessage());
	cout << "Exception message is: \n"
	<< message << "\n";
	delete [] message;
	return -1;
	}
	catch (...) {
	cout << "Unexpected Exception \n" ;
	return -1;
	}

	delete parser;
	delete docHandler;
	return 0;
	}</source>
	</s3>

	<anchor name="SAXFeatures"/>
	<s3 title="SAXParser Supported Features">

	<p>The behavior of the SAXParser is dependant on the values of the following features. All
	of the features below are set using the "setter" methods (e.g. <code>setDoNamespaces</code>),
	and are queried using the corresponding "getter" methods (e.g. <code>getDoNamespaces</code>).
	The following only gives you a quick summary of supported features. Please
	refer to <jump href="api.html">API Documentataion</jump> for complete detail.
	</p>
	<p>None of these features can be modified in the middle of a parse, or an exception will be thrown.</p>


	<anchor name="namespaces"/>
	<table>
	<tr><th colspan="2"><em>void setDoNamespaces(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> Perform Namespace processing. </td></tr>
	<tr><th><em>false:</em></th><td> Do not perform Namespace processing. </td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note:</em></th><td> If the validation scheme is set to Val_Always or Val_Auto, then the
	document must contain a grammar that supports the use of namespaces. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="validation-dynamic">setValidationScheme</link>
	</td></tr>
	</table>
	<p/>

	<anchor name="validation"/>
	<table>
	<tr><th colspan="2"><em>void setDoValidation(const bool)</em> (deprecated) <br/>
	please use <link anchor="validation-dynamic">setValidationScheme</link>.
	</th></tr>
	<tr><th><em>true:</em></th><td> Report all validation errors. </td></tr>
	<tr><th><em>false:</em></th><td> Do not report validation errors. </td></tr>
	<tr><th><em>default:</em></th><td> see the default of
	<link anchor="validation-dynamic">setValidationScheme</link>.
	</td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="validation-dynamic">setValidationScheme</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="validation-dynamic"/>
	<table>
	<tr><th colspan="2"><em>void setValidationScheme(const ValSchemes)</em></th></tr>
	<tr><th><em>Val_Auto:</em></th><td> The parser will report validation errors only if a grammar is specified. </td></tr>
	<tr><th><em>Val_Always:</em></th><td> The parser will always report validation errors. </td></tr>
	<tr><th><em>Val_Never:</em></th><td> Do not report validation errors. </td></tr>
	<tr><th><em>default:</em></th><td> Val_Auto </td></tr>
	<tr><th><em>note:</em></th><td> If set to Val_Always, the document must
	specify a grammar. If this feature is set to Val_Never and document specifies a grammar,
	that grammar might be parsed but no validation of the document contents will be
	performed. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="load-external-dtd">setLoadExternalDTD</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="schema"/>
	<table>
	<tr><th colspan="2"><em>void setDoSchema(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> Enable the parser's schema support. </td></tr>
	<tr><th><em>false:</em></th><td> Disable the parser's schema support. </td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note</em></th><td> If set to true, namespace processing must also be turned on. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="namespaces">setDoNamespaces</link>
	</td></tr>
	</table>

	<p/>

	<table>
	<tr><th colspan="2"><em>void setValidationSchemaFullChecking(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> Enable full schema constraint checking, including checking
	which may be time-consuming or memory intensive. Currently, particle unique
	attribution constraint checking and particle derivation restriction checking
	are controlled by this option. </td></tr>
	<tr><th><em>false:</em></th><td> Disable full schema constraint checking. </td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note:</em></th><td> This feature checks the Schema grammar itself for
	additional errors that are time-consuming or memory intensive. It does <em>not</em> affect the
	level of checking performed on document instances that use Schema grammars. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="schema">setDoSchema</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="load-external-dtd"/>
	<table>
	<tr><th colspan="2"><em>void setLoadExternalDTD(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> Load the External DTD . </td></tr>
	<tr><th><em>false:</em></th><td> Ignore the external DTD completely. </td></tr>
	<tr><th><em>default:</em></th><td> true </td></tr>
	<tr><th><em>note</em></th><td> This feature is ignored and DTD is always loaded
	if the validation scheme is set to Val_Always or Val_Auto. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="validation-dynamic">setValidationScheme</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="continue-after-fatal"/>
	<table>
	<tr><th colspan="2"><em>void setExitOnFirstFatalError(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> Stops parse on first fatal error. </td></tr>
	<tr><th><em>false:</em></th><td> Attempt to continue parsing after a fatal error. </td></tr>
	<tr><th><em>default:</em></th><td> true </td></tr>
	<tr><th><em>note:</em></th><td> The behavior of the parser when this feature is set to
	false is <em>undetermined</em>! Therefore use this feature with extreme caution because
	the parser may get stuck in an infinite loop or worse. </td></tr>
	</table>

	<p/>

	<table>
	<tr><th colspan="2"><em>void setValidationConstraintFatal(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td> The parser will treat validation error as fatal and will
	exit depends on the state of
	<link anchor="continue-after-fatal">setExitOnFirstFatalError</link>.
	</td></tr>
	<tr><th><em>false:</em></th><td> The parser will report the error and continue processing. </td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note:</em></th><td> Setting this true does not mean the validation error will
	be printed with the word "Fatal Error". It is still printed as "Error", but the parser
	will exit if
	<link anchor="continue-after-fatal">setExitOnFirstFatalError</link>
	is set to true. </td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="continue-after-fatal">setExitOnFirstFatalError</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="use-cached"/>
	<table>
	<tr><th colspan="2"><em>void useCachedGrammarInParse(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td>Use cached grammar if it exists in the pool.</td></tr>
	<tr><th><em>false:</em></th><td>Parse the schema grammar.</td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note:</em></th><td>The getter function for this method is called isUsingCachedGrammarInParse</td></tr>
	<tr><th><em>note:</em></th><td>If the grammar caching option is enabled, this option is set to true automatically.
	Any setting to this option by the users is a no-op.</td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="cache-grammar">cacheGrammarFromParse</link>
	</td></tr>
	</table>

	<p/>

	<anchor name="cache-grammar"/>
	<table>
	<tr><th colspan="2"><em>void cacheGrammarFromParse(const bool)</em></th></tr>
	<tr><th><em>true:</em></th><td>Cache the grammar in the pool for re-use in subsequent parses.</td></tr>
	<tr><th><em>false:</em></th><td>Do not cache the grammar in the pool</td></tr>
	<tr><th><em>default:</em></th><td> false </td></tr>
	<tr><th><em>note:</em></th><td>The getter function for this method is called isCachingGrammarFromParse</td></tr>
	<tr><th><em>note:</em></th><td> If set to true, the useCachedGrammarInParse
	is also set to true automatically.</td></tr>
	<tr><th><em>see:</em></th><td>
	<link anchor="use-cached">useCachedGrammarInParse</link>
	</td></tr>
	</table>

	<p/>

	<table>
	<tr><th colspan="2"><em>void setExternalSchemaLocation(const XMLCh* const)</em></th></tr>
	<tr><th><em>Description</em></th><td> The XML Schema Recommendation explicitly states that
	the inclusion of schemaLocation/ noNamespaceSchemaLocation attributes in the
	instance document is only a hint; it does not mandate that these attributes
	must be used to locate schemas. Similar situation happens to <import>
	element in schema documents. This property allows the user to specify a list
	of schemas to use. If the targetNamespace of a schema specified using this
	method matches the targetNamespace of a schema occurring in the instance
	document in schemaLocation attribute, or
	if the targetNamespace matches the namespace attribute of <import>
	element, the schema specified by the user using this property will
	be used (i.e., the schemaLocation attribute in the instance document
	or on the <import> element will be effectively ignored). </td></tr>
	<tr><th><em>Value</em></th><td> The syntax is the same as for schemaLocation attributes
	in instance documents: e.g, "http://www.example.com file_name.xsd".
	The user can specify more than one XML Schema in the list. </td></tr>
	<tr><th><em>Value Type</em></th><td> XMLCh* </td></tr>
	</table>

	<p/>
	<table>
	<tr><th colspan="2"><em>void setExternalNoNamespaceSchemaLocation(const XMLCh* const)</em></th></tr>
	<tr><th><em>Description</em></th><td> The XML Schema Recommendation explicitly states that
	the inclusion of schemaLocation/ noNamespaceSchemaLocation attributes in the
	instance document is only a hint; it does not mandate that these attributes
	must be used to locate schemas. This property allows the user to specify the
	no target namespace XML Schema Location externally. If specified, the instance
	document's noNamespaceSchemaLocation attribute will be effectively ignored. </td></tr>
	<tr><th><em>Value</em></th><td> The syntax is the same as for the noNamespaceSchemaLocation
	attribute that may occur in an instance document: e.g."file_name.xsd". </td></tr>
	<tr><th><em>Value Type</em></th><td> XMLCh* </td></tr>
	</table>

	<p/>

	</s3>
	</s2>

	</s1>