## org.apache.xerces.framework
Class XMLParser

    java.lang.Object
      |
      +--org.apache.xerces.framework.XMLParser

Direct Known Subclasses:
  DOMParser, SAXParser

public abstract class XMLParser
extends java.lang.Object
implements XMLErrorReporter, XMLDocumentHandler.DTDHandler

This is the base class of all standard parsers.

Version:
  $Id: XMLParser.java,v 1.33.2.5 2001/11/13 20:48:14 neilg Exp $

Field Summary
`protected DefaultEntityHandler` `fEntityHandler`
`protected XMLErrorReporter` `fErrorReporter`
`protected GrammarResolver` `fGrammarResolver`
`protected boolean` `fParseInProgress`
`protected XMLDocumentScanner` `fScanner`
`protected StringPool` `fStringPool`
`protected XMLValidator` `fValidator`
`protected static java.lang.String` `SAX2_FEATURES_PREFIX` SAX2 features prefix (http://xml.org/sax/features/).
`protected static java.lang.String` `SAX2_PROPERTIES_PREFIX` SAX2 properties prefix (http://xml.org/sax/properties/).
`protected static java.lang.String` `XERCES_FEATURES_PREFIX` Xerces features prefix (http://apache.org/xml/features/).
`protected static java.lang.String` `XERCES_PROPERTIES_PREFIX` Xerces properties prefix (http://apache.org/xml/properties/).

Fields inherited from interface org.apache.xerces.framework.XMLErrorReporter
`ERRORTYPE_FATAL_ERROR, ERRORTYPE_RECOVERABLE_ERROR, ERRORTYPE_WARNING`

Constructor Summary
`protected` `XMLParser()` Constructor
`protected` `XMLParser(StringPool stringPool)`

Method Summary
`void` `addRecognizer(XMLDeclRecognizer recognizer)` Adds a recognizer.
`protected boolean` `getAllowJavaEncodings()` Returns true if Java encoding names are allowed in the XML document.
`protected boolean` `getContinueAfterFatalError()` Returns true if the parser continues after a fatal error.
`EntityResolver` `getEntityResolver()` Return the current entity resolver.
`ErrorHandler` `getErrorHandler()` Return the current error handler.
`protected boolean` `getExternalGeneralEntities()` Note: This feature is always true.
`protected boolean` `getExternalParameterEntities()` Note: This feature is always true.
`boolean` `getFeature(java.lang.String featureId)` Query the state of a feature.
`java.lang.String[]` `getFeaturesRecognized()` Returns a list of features that this parser recognizes.
`XMLMessageProvider` `getfgDatatypeMessages()` return the Datatypes Messages object
`XMLMessageProvider` `getfgImplementationMessages()` return the Implementation Messages object
`XMLMessageProvider` `getfgSchemaMessages()` return the Schema Messages object
`XMLMessageProvider` `getfgXMLMessages()` return the XML Messages object
`java.util.Locale` `getfLocale()` return the locale
`protected boolean` `getLoadDTDGrammar()` Returns true if load DTD grammar is turned on in the XMLValiator.
`protected boolean` `getLoadExternalDTD()` Returns true if loading of the external DTD is on.
`Locator` `getLocator()` return the locator being used by the parser
`protected boolean` `getNamespaces()` Returns true if the parser preprocesses namespaces.
`protected boolean` `getNormalizeContents()`
`java.lang.String[]` `getPropertiesRecognized()` Returns a list of properties that this parser recognizes.
`java.lang.Object` `getProperty(java.lang.String propertyId)` Query the value of a property.
`protected boolean` `getValidation()` Returns true if validation is turned on.
`protected boolean` `getValidationDynamic()` Returns true if validation is based on whether a document contains a grammar.
`protected boolean` `getValidationSchema()` Returns true if Schema support is turned on.
`protected boolean` `getValidationSchemaFullChecking()` Returns true if Schema support is turned on.
`protected boolean` `getValidationWarnOnDuplicateAttdef()` Returns true if an error is emitted when an attribute is redefined in the grammar.
`protected boolean` `getValidationWarnOnUndeclaredElemdef()` Returns true if the parser emits an error when an undeclared element is referenced in the grammar.
`protected java.lang.String` `getXMLString()` This method is the equivalent to the property:
`protected void` `initHandlers(boolean sendCharDataAsCharArray, XMLDocumentHandler docHandler, XMLDocumentHandler.DTDHandler dtdHandler)` Set char data processing preference and handlers.
`boolean` `isFeatureRecognized(java.lang.String featureId)` Returns true if the specified feature is recognized.
`boolean` `isPropertyRecognized(java.lang.String propertyId)` Returns true if the specified property is recognized.
`void` `parse(InputSource source)` Parses the specified input source.
`void` `parse(java.lang.String systemId)` Parses the input source specified by the given system identifier.
`boolean` `parseSome()` Application-driven parsing.
`boolean` `parseSomeSetup(InputSource source)` Setup for application-driven parsing.
`void` `reportError(Locator locator, java.lang.String errorDomain, int majorCode, int minorCode, java.lang.Object[] args, int errorType)` Report an error.
`void` `reset()` Reset parser instance so that it can be reused.
`protected void` `resetOrCopy()` Reset or copy parser Allows parser instance reuse
`protected void` `setAllowJavaEncodings(boolean allow)` Allows the use of Java encoding names in the XMLDecl and TextDecl lines in an XML document.
`protected void` `setContinueAfterFatalError(boolean continueAfterFatalError)` Allows the parser to continue after a fatal error.
`void` `setEntityResolver(EntityResolver resolver)` Sets the resolver used to resolve external entities.
`void` `setErrorHandler(ErrorHandler handler)` Sets the error handler.
`protected void` `setExternalGeneralEntities(boolean expand)` Note: Currently, this parser always expands external general entities. Setting this feature to false will throw a SAXNotSupportedException.
`protected void` `setExternalNoNamespaceSchemaLocation(java.lang.Object value)` Allows the user to set external XML Schema with no target Namespace.
`protected void` `setExternalParameterEntities(boolean expand)` Note: Currently, this parser always expands external parameter entities. Setting this feature to false will throw a SAXNotSupportedException.
`protected void` `setExternalSchemaLocation(java.lang.Object value)` Allows the user to set a list of external XML Schemas (ex."http://example.com schema.xsd") to be used by the parser.
`void` `setFeature(java.lang.String featureId, boolean state)` Set the state of a feature.
`protected void` `setLoadDTDGrammar(boolean loadDTDGrammar)` Allows the parser to have the choice to load DTD grammar when validation is off.
`protected void` `setLoadExternalDTD(boolean loadExternalDTD)` Allows the parser to have the choice to load the external DTD when validation is off.
`void` `setLocale(java.util.Locale locale)` Set the locale to use for messages.
`protected void` `setNamespaces(boolean process)` Sets whether the parser preprocesses namespaces.
`protected void` `setNormalizeAttributeValues(boolean normalize)`
`protected void` `setNormalizeContents(boolean normalize)` Normalization of element content is controlled by this feature.
`void` `setProperty(java.lang.String propertyId, java.lang.Object value)` Set the value of a property.
`void` `setReaderFactory(XMLEntityReaderFactory readerFactory)` Set the reader factory.
`protected void` `setValidation(boolean validate)` Sets whether the parser validates.
`protected void` `setValidationDynamic(boolean dynamic)` Allows the parser to validate a document only when it contains a grammar.
`protected void` `setValidationSchema(boolean schema)` Allows the user to turn Schema support on/off.
`protected void` `setValidationSchemaFullChecking(boolean schemaFullChecking)` Allows the user to turn full Schema constraint checking on/off.
`protected void` `setValidationWarnOnDuplicateAttdef(boolean warn)` Sets whether an error is emitted when an attribute is redefined in the grammar.
`protected void` `setValidationWarnOnUndeclaredElemdef(boolean warn)` Sets whether the parser emits an error when an element's content model references an element by name that is not declared in the grammar.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### SAX2_FEATURES_PREFIX

    protected static final java.lang.String SAX2_FEATURES_PREFIX

  SAX2 features prefix (http://xml.org/sax/features/).

### SAX2_PROPERTIES_PREFIX

    protected static final java.lang.String SAX2_PROPERTIES_PREFIX

  SAX2 properties prefix (http://xml.org/sax/properties/).

### XERCES_FEATURES_PREFIX

    protected static final java.lang.String XERCES_FEATURES_PREFIX

  Xerces features prefix (http://apache.org/xml/features/).

### XERCES_PROPERTIES_PREFIX

    protected static final java.lang.String XERCES_PROPERTIES_PREFIX

  Xerces properties prefix (http://apache.org/xml/properties/).

### fGrammarResolver

    protected GrammarResolver fGrammarResolver

### fParseInProgress

    protected boolean fParseInProgress

### fStringPool

    protected StringPool fStringPool

### fErrorReporter

    protected XMLErrorReporter fErrorReporter

### fEntityHandler

    protected DefaultEntityHandler fEntityHandler

### fScanner

    protected XMLDocumentScanner fScanner

### fValidator

    protected XMLValidator fValidator

Constructor Detail

### XMLParser

    protected XMLParser()

  Constructor

### XMLParser

    protected XMLParser(StringPool stringPool)

Method Detail

### initHandlers

    protected void initHandlers(boolean sendCharDataAsCharArray,
                                XMLDocumentHandler docHandler,
                                XMLDocumentHandler.DTDHandler dtdHandler)

  Set char data processing preference and handlers.

### getFeaturesRecognized

    public java.lang.String[] getFeaturesRecognized()

  Returns a list of features that this parser recognizes. This method will never return null; if no features are recognized, this method will return a zero length array.
  See Also:
    `isFeatureRecognized(java.lang.String)`, `setFeature(java.lang.String, boolean)`, `getFeature(java.lang.String)`

### isFeatureRecognized

    public boolean isFeatureRecognized(java.lang.String featureId)

  Returns true if the specified feature is recognized.
  See Also:
    `getFeaturesRecognized()`, `setFeature(java.lang.String, boolean)`, `getFeature(java.lang.String)`

### getPropertiesRecognized

    public java.lang.String[] getPropertiesRecognized()

  Returns a list of properties that this parser recognizes. This method will never return null; if no properties are recognized, this method will return a zero length array.
  See Also:
    `isPropertyRecognized(java.lang.String)`, `setProperty(java.lang.String, java.lang.Object)`, `getProperty(java.lang.String)`

### isPropertyRecognized

    public boolean isPropertyRecognized(java.lang.String propertyId)

  Returns true if the specified property is recognized.
  See Also:
    `getPropertiesRecognized()`, `setProperty(java.lang.String, java.lang.Object)`, `getProperty(java.lang.String)`

### parseSomeSetup

    public boolean parseSomeSetup(InputSource source)
                           throws java.lang.Exception

  Setup for application-driven parsing.
  Parameters:
    `source` - the input source to be parsed.
  See Also:
    `parseSome()`

### parseSome

    public boolean parseSome()
                      throws java.lang.Exception

  Application-driven parsing.
  See Also:
    `parseSomeSetup(org.xml.sax.InputSource)`

### reset

    public void reset()
               throws java.lang.Exception

  Reset parser instance so that it can be reused.

### getLocator

    public final Locator getLocator()

  return the locator being used by the parser
  Specified by:
    getLocator in interface XMLErrorReporter
  Returns:
    the parser's active locator

### getfLocale

    public final java.util.Locale getfLocale()

  return the locale
  Returns:
    the locale

### getfgXMLMessages

    public final XMLMessageProvider getfgXMLMessages()

  return the XML Messages object
  Returns:
    the parser's messages object

### getfgImplementationMessages

    public final XMLMessageProvider getfgImplementationMessages()

  return the Implementation Messages object
  Returns:
    the parser's implementation messages

### getfgSchemaMessages

    public final XMLMessageProvider getfgSchemaMessages()

  return the Schema Messages object
  Returns:
    the parser's schema messages

### getfgDatatypeMessages

    public final XMLMessageProvider getfgDatatypeMessages()

  return the Datatypes Messages object
  Returns:
    the parser's datatypes messages

### setReaderFactory

    public void setReaderFactory(XMLEntityReaderFactory readerFactory)

  Set the reader factory.

### addRecognizer

    public void addRecognizer(XMLDeclRecognizer recognizer)

  Adds a recognizer.
  Parameters:
    `recognizer` - The XML recognizer to add.

### setValidation

    protected void setValidation(boolean validate)
                          throws SAXNotRecognizedException,
                                 SAXNotSupportedException

  Sets whether the parser validates.

  This method is the equivalent to the feature:

       http://xml.org/sax/features/validation

  Parameters:
    `validate` - True to validate; false to not validate.
  See Also:
    `getValidation()`, `setFeature(java.lang.String, boolean)`

### getValidation

    protected boolean getValidation()
                             throws SAXNotRecognizedException,
                                    SAXNotSupportedException

  Returns true if validation is turned on.
  See Also:
    `setValidation(boolean)`

### setExternalGeneralEntities

    protected void setExternalGeneralEntities(boolean expand)
                                       throws SAXNotRecognizedException,
                                              SAXNotSupportedException

  Note: Currently, this parser always expands external general entities. Setting this feature to false will throw a SAXNotSupportedException.

  Sets whether external general entities are expanded.

  This method is the equivalent to the feature:

       http://xml.org/sax/features/external-general-entities

  Parameters:
    `expand` - True to expand external general entities; false to not expand.
  See Also:
    `getExternalGeneralEntities()`, `setFeature(java.lang.String, boolean)`

### getExternalGeneralEntities

    protected boolean getExternalGeneralEntities()
                                          throws SAXNotRecognizedException,
                                                 SAXNotSupportedException

  Note: This feature is always true.

  Returns true if external general entities are expanded.

  See Also:
    `setExternalGeneralEntities(boolean)`

### setExternalParameterEntities

    protected void setExternalParameterEntities(boolean expand)
                                         throws SAXNotRecognizedException,
                                                SAXNotSupportedException

  Note: Currently, this parser always expands external parameter entities. Setting this feature to false will throw a SAXNotSupportedException.

  Sets whether external parameter entities are expanded.

  This method is the equivalent to the feature:

       http://xml.org/sax/features/external-parameter-entities

  Parameters:
    `expand` - True to expand external parameter entities; false to not expand.
  See Also:
    `getExternalParameterEntities()`, `setFeature(java.lang.String, boolean)`

### getExternalParameterEntities

    protected boolean getExternalParameterEntities()
                                            throws SAXNotRecognizedException,
                                                   SAXNotSupportedException

  Note: This feature is always true.

  Returns true if external parameter entities are expanded.

  See Also:
    `setExternalParameterEntities(boolean)`

### setNamespaces

    protected void setNamespaces(boolean process)
                          throws SAXNotRecognizedException,
                                 SAXNotSupportedException

  Sets whether the parser preprocesses namespaces.

  This method is the equivalent to the feature:

       http://xml.org/sax/features/namespaces

  Parameters:
    `process` - True to process namespaces; false to not process.
  See Also:
    `getNamespaces()`, `setFeature(java.lang.String, boolean)`

### getNamespaces

    protected boolean getNamespaces()
                             throws SAXNotRecognizedException,
                                    SAXNotSupportedException

  Returns true if the parser preprocesses namespaces.
  See Also:
    `setNamespaces(boolean)`

### setValidationSchema

    protected void setValidationSchema(boolean schema)
                                throws SAXNotRecognizedException,
                                       SAXNotSupportedException

  Allows the user to turn Schema support on/off.

  This method is equivalent to the feature:

       http://apache.org/xml/features/validation/schema

  Parameters:
    `schema` - True to turn on Schema support; false to turn it off.
  See Also:
    `getValidationSchema()`, `setFeature(java.lang.String, boolean)`

### getValidationSchema

    protected boolean getValidationSchema()
                                   throws SAXNotRecognizedException,
                                          SAXNotSupportedException

  Returns true if Schema support is turned on.
  See Also:
    `setValidationSchema(boolean)`

### setValidationSchemaFullChecking

    protected void setValidationSchemaFullChecking(boolean schemaFullChecking)
                                            throws SAXNotRecognizedException,
                                                   SAXNotSupportedException

  Allows the user to turn full Schema constraint checking on/off. Only takes effect if Schema validation is enabled. If this feature is off, partial constraint checking is done.

  This method is equivalent to the feature:

       http://apache.org/xml/features/validation/schema-full-checking

  Parameters:
    `schemaFullChecking` - True to turn on full schema constraint checking.
  See Also:
    `getValidationSchemaFullChecking()`, `setFeature(java.lang.String, boolean)`

### setNormalizeContents

    protected void setNormalizeContents(boolean normalize)

  Normalization of element content is controlled by this feature. If this feature is set to true, DOM and SAX APIs will expose element content that is normalized according to XML Schema REC. Otherwise, element content will be exposed as required by the infoset.
  Parameters:
    `normalize` -

### getNormalizeContents

    protected boolean getNormalizeContents()

### setExternalSchemaLocation

    protected void setExternalSchemaLocation(java.lang.Object value)
                                      throws SAXNotRecognizedException,
                                             SAXNotSupportedException

  Allows the user to set a list of external XML Schemas (ex."http://example.com schema.xsd") to be used by the parser. If two schemas with the same targetNamespace appear in both the list and a document, the one from the list will be picked up. See XML Schema REC: http://www.w3.org/TR/xmlschema-1/#schema-loc

  This method is equivalent to the property:

      http://apache.org/xml/properties/schema/external-schemaLocation

  Parameters:
    `value` - The list of schemas.
  Throws:
    SAXNotRecognizedException -
    SAXNotSupportedException -

### setExternalNoNamespaceSchemaLocation

    protected void setExternalNoNamespaceSchemaLocation(java.lang.Object value)
                                                 throws SAXNotRecognizedException,
                                                        SAXNotSupportedException

  Allows the user to set external XML Schema with no target Namespace. This value overwrites the value on the _noNamespaceSchemaLocation_. See XML Schema REC: http://www.w3.org/TR/xmlschema-1/#schema-loc

  This method is equivalent to the property:

      http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation

  Parameters:
    `value` - An XML Schema file name
  Throws:
    SAXNotRecognizedException -
    SAXNotSupportedException -

### getValidationSchemaFullChecking

    protected boolean getValidationSchemaFullChecking()
                                               throws SAXNotRecognizedException,
                                                      SAXNotSupportedException

  Returns true if Schema support is turned on.
  See Also:
    `setValidationSchemaFullChecking(boolean)`

### setValidationDynamic

    protected void setValidationDynamic(boolean dynamic)
                                 throws SAXNotRecognizedException,
                                        SAXNotSupportedException

  Allows the parser to validate a document only when it contains a grammar. Validation is turned on/off based on each document instance, automatically.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/validation/dynamic

  Parameters:
    `dynamic` - True to dynamically validate documents; false to validate based on the validation feature.
  See Also:
    `getValidationDynamic()`, `setFeature(java.lang.String, boolean)`

### getValidationDynamic

    protected boolean getValidationDynamic()
                                    throws SAXNotRecognizedException,
                                           SAXNotSupportedException

  Returns true if validation is based on whether a document contains a grammar.
  See Also:
    `setValidationDynamic(boolean)`

### setNormalizeAttributeValues

    protected void setNormalizeAttributeValues(boolean normalize)

### setLoadDTDGrammar

    protected void setLoadDTDGrammar(boolean loadDTDGrammar)
                              throws SAXNotRecognizedException,
                                     SAXNotSupportedException

  Allows the parser to have the choice to load DTD grammar when validation is off.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/nonvalidating/load-dtd-grammar

  Parameters:
    `loadDTDGrammar` - True to turn on the feature; false to turn off the feature.
  See Also:
    `getLoadDTDGrammar()`, `setFeature(java.lang.String, boolean)`

### getLoadDTDGrammar

    protected boolean getLoadDTDGrammar()
                                 throws SAXNotRecognizedException,
                                        SAXNotSupportedException

  Returns true if load DTD grammar is turned on in the XMLValiator.
  See Also:
    `setLoadDTDGrammar(boolean)`

### setLoadExternalDTD

    protected void setLoadExternalDTD(boolean loadExternalDTD)
                               throws SAXNotRecognizedException,
                                      SAXNotSupportedException

  Allows the parser to have the choice to load the external DTD when validation is off.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/nonvalidating/load-external-dtd

  Parameters:
    `loadExternalDTD` - True to turn on the feature; false to turn off the feature.
  See Also:
    `getLoadExternalDTD()`, `setFeature(java.lang.String, boolean)`

### getLoadExternalDTD

    protected boolean getLoadExternalDTD()
                                  throws SAXNotRecognizedException,
                                         SAXNotSupportedException

  Returns true if loading of the external DTD is on.
  See Also:
    `setLoadExternalDTD(boolean)`

### setValidationWarnOnDuplicateAttdef

    protected void setValidationWarnOnDuplicateAttdef(boolean warn)
                                               throws SAXNotRecognizedException,
                                                      SAXNotSupportedException

  Sets whether an error is emitted when an attribute is redefined in the grammar.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/validation/warn-on-duplicate-attdef

  Parameters:
    `warn` - True to warn; false to not warn.
  See Also:
    `getValidationWarnOnDuplicateAttdef()`, `setFeature(java.lang.String, boolean)`

### getValidationWarnOnDuplicateAttdef

    protected boolean getValidationWarnOnDuplicateAttdef()
                                                  throws SAXNotRecognizedException,
                                                         SAXNotSupportedException

  Returns true if an error is emitted when an attribute is redefined in the grammar.
  See Also:
    `setValidationWarnOnDuplicateAttdef(boolean)`

### setValidationWarnOnUndeclaredElemdef

    protected void setValidationWarnOnUndeclaredElemdef(boolean warn)
                                                 throws SAXNotRecognizedException,
                                                        SAXNotSupportedException

  Sets whether the parser emits an error when an element's content model references an element by name that is not declared in the grammar.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/validation/warn-on-undeclared-elemdef

  Parameters:
    `warn` - True to warn; false to not warn.
  See Also:
    `getValidationWarnOnUndeclaredElemdef()`, `setFeature(java.lang.String, boolean)`

### getValidationWarnOnUndeclaredElemdef

    protected boolean getValidationWarnOnUndeclaredElemdef()
                                                    throws SAXNotRecognizedException,
                                                           SAXNotSupportedException

  Returns true if the parser emits an error when an undeclared element is referenced in the grammar.
  See Also:
    `setValidationWarnOnUndeclaredElemdef(boolean)`

### setAllowJavaEncodings

    protected void setAllowJavaEncodings(boolean allow)
                                  throws SAXNotRecognizedException,
                                         SAXNotSupportedException

  Allows the use of Java encoding names in the XMLDecl and TextDecl lines in an XML document.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/allow-java-encodings

  Parameters:
    `allow` - True to allow Java encoding names; false to disallow.
  See Also:
    `getAllowJavaEncodings()`, `setFeature(java.lang.String, boolean)`

### getAllowJavaEncodings

    protected boolean getAllowJavaEncodings()
                                     throws SAXNotRecognizedException,
                                            SAXNotSupportedException

  Returns true if Java encoding names are allowed in the XML document.
  See Also:
    `setAllowJavaEncodings(boolean)`

### setContinueAfterFatalError

    protected void setContinueAfterFatalError(boolean continueAfterFatalError)
                                       throws SAXNotRecognizedException,
                                              SAXNotSupportedException

  Allows the parser to continue after a fatal error. Normally, a fatal error would stop the parse.

  This method is the equivalent to the feature:

       http://apache.org/xml/features/continue-after-fatal-error

  Parameters:
    `continueAfterFatalError` - True to continue; false to stop on fatal error.
  See Also:
    `getContinueAfterFatalError()`, `setFeature(java.lang.String, boolean)`

### getContinueAfterFatalError

    protected boolean getContinueAfterFatalError()
                                          throws SAXNotRecognizedException,
                                                 SAXNotSupportedException

  Returns true if the parser continues after a fatal error.
  See Also:
    `setContinueAfterFatalError(boolean)`

### getXMLString

    protected java.lang.String getXMLString()
                                     throws SAXNotRecognizedException,
                                            SAXNotSupportedException

  This method is the equivalent to the property:

       http://xml.org/sax/properties/xml-string

  See Also:
    `getProperty(java.lang.String)`

### resetOrCopy

    protected void resetOrCopy()
                        throws java.lang.Exception

  Reset or copy parser Allows parser instance reuse

### setEntityResolver

    public void setEntityResolver(EntityResolver resolver)

  Sets the resolver used to resolve external entities. The EntityResolver interface supports resolution of public and system identifiers.
  Parameters:
    `resolver` - The new entity resolver. Passing a null value will uninstall the currently installed resolver.

### getEntityResolver

    public EntityResolver getEntityResolver()

  Return the current entity resolver.
  Returns:
    The current entity resolver, or null if none has been registered.
  See Also:
    `setEntityResolver(org.xml.sax.EntityResolver)`

### setErrorHandler

    public void setErrorHandler(ErrorHandler handler)

  Sets the error handler.
  Parameters:
    `handler` - The new error handler.

### getErrorHandler

    public ErrorHandler getErrorHandler()

  Return the current error handler.
  Returns:
    The current error handler, or null if none has been registered.
  See Also:
    `setErrorHandler(org.xml.sax.ErrorHandler)`

### parse

    public void parse(InputSource source)
               throws SAXException,
                      java.io.IOException

  Parses the specified input source.
  Parameters:
    `source` - The input source.
  Throws:
    SAXException - Throws exception on SAX error.
    java.io.IOException - Throws exception on i/o error.

### parse

    public void parse(java.lang.String systemId)
               throws SAXException,
                      java.io.IOException

  Parses the input source specified by the given system identifier.

  This method is almost equivalent to the following:

           parse(new InputSource(systemId));

  The only difference is that this method will attempt to close the stream that was opened.
  Parameters:
    `source` - The input source.
  Throws:
    SAXException - Throws exception on SAX error.
    java.io.IOException - Throws exception on i/o error.

### setLocale

    public void setLocale(java.util.Locale locale)
                   throws SAXException

  Set the locale to use for messages.
  Parameters:
    `locale` - The locale object to use for localization of messages.
  Throws:
    SAXException - An exception thrown if the parser does not support the specified locale.
  See Also:
    `Parser`

### reportError

    public void reportError(Locator locator,
                            java.lang.String errorDomain,
                            int majorCode,
                            int minorCode,
                            java.lang.Object[] args,
                            int errorType)
                     throws java.lang.Exception

  Report an error.
  Specified by:
    reportError in interface XMLErrorReporter
  Parameters:
    `locator` - Location of error.
    `errorDomain` - The error domain.
    `majorCode` - The major code of the error.
    `minorCode` - The minor code of the error.
    `args` - Arguments for replacement text.
    `errorType` - The type of the error.
  Throws:
    java.lang.Exception - Thrown on error.
  See Also:
    `XMLErrorReporter.ERRORTYPE_WARNING`, `XMLErrorReporter.ERRORTYPE_FATAL_ERROR`

### setFeature

    public void setFeature(java.lang.String featureId,
                           boolean state)
                    throws SAXNotRecognizedException,
                           SAXNotSupportedException

  Set the state of a feature. Set the state of any feature in a SAX2 parser. The parser might not recognize the feature, and if it does recognize it, it might not be able to fulfill the request.
  Parameters:
    `featureId` - The unique identifier (URI) of the feature.
    `state` - The requested state of the feature (true or false).
  Throws:
    SAXNotRecognizedException - If the requested feature is not known.
    SAXNotSupportedException - If the requested feature is known, but the requested state is not supported.
    SAXException - If there is any other problem fulfilling the request.

### getFeature

    public boolean getFeature(java.lang.String featureId)
                       throws SAXNotRecognizedException,
                              SAXNotSupportedException

  Query the state of a feature. Query the current state of any feature in a SAX2 parser. The parser might not recognize the feature.
  Parameters:
    `featureId` - The unique identifier (URI) of the feature being set.
  Returns:
    The current state of the feature.
  Throws:
    SAXNotRecognizedException - If the requested feature is not known.
    SAXException - If there is any other problem fulfilling the request.

### setProperty

    public void setProperty(java.lang.String propertyId,
                            java.lang.Object value)
                     throws SAXNotRecognizedException,
                            SAXNotSupportedException

  Set the value of a property. Set the value of any property in a SAX2 parser. The parser might not recognize the property, and if it does recognize it, it might not support the requested value.
  Parameters:
    `propertyId` - The unique identifier (URI) of the property being set.
    `Object` - The value to which the property is being set.
  Throws:
    SAXNotRecognizedException - If the requested property is not known.
    SAXNotSupportedException - If the requested property is known, but the requested value is not supported.
    SAXException - If there is any other problem fulfilling the request.

### getProperty

    public java.lang.Object getProperty(java.lang.String propertyId)
                                 throws SAXNotRecognizedException,
                                        SAXNotSupportedException

  Query the value of a property. Return the current value of a property in a SAX2 parser. The parser might not recognize the property.
  Parameters:
    `propertyId` - The unique identifier (URI) of the property being set.
  Returns:
    The current value of the property.
  Throws:
    SAXNotRecognizedException - If the requested property is not known.
    SAXException - If there is any other problem fulfilling the request.
  See Also:
    `XMLReader.getProperty(java.lang.String)`

Copyright © 1999-2001 Apache XML Project. All Rights Reserved.