java.lang.Object
- org.mdiutil.xml.XMLSAXParser

All Implemented Interfaces:: InputSourceCaching

public class XMLSAXParser
extends Object
implements InputSourceCaching

A generic XML SAX Parser. The underlying parser can be configured for XML validation.

Examples

Create a validating parser using a DTD

   XMLSAXParser parser = new XMLSAXParser("My Parser");
   parser.setValidating(true);
   parser.setHandlerDTD(dtd);
   parser.setHandler(handler);
   parse.parse(file);

Create a validating parser using a Schema

   XMLSAXParser parser = new XMLSAXParser("My Parser");
   parser.setValidating(true);
   parser.setSchema(schema);
   parser.setHandler(handler);
   parse.parse(file);

Create a validating parser and get the parsing exceptions

   XMLSAXParser parser = new XMLSAXParser("My Parser");
   parser.setValidating(true);
   parser.setSchema(schema);
   parser.setHandler(handler);
   parser.showExceptions(false);
   parse.parse(file);

   if (handler.hasParserExceptions()) {
     List>ResolverSAXHandler.ExceptionResult> results = handler.getExceptionResults();
   }

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`DEFAULT_ERROR_TITLE` The default error title used for the dialog.
`protected URL`	`dtd` The DTD used to validate the parsing.
`protected String`	`encoding` The encoding.
`protected String`	`errorTitle` The error title.
`protected ParserExceptionListener`	`exListener` The listener which is fired if exceptions (including SAXExceptions) are encountered during the parsing.
`protected Map<String,Boolean>`	`features` The features of the parser factory.
`protected Throwable`	`firstException` The first throwable thrown by the parser, if the parsing failed beca use of an exception in the handler.
`protected ResolverSAXHandler`	`handler` The associated SAX handler.
`protected boolean`	`hasDefaultLSResolver` True if a default resource resolver should be set even if no resolver has been specified.
`protected boolean`	`isNameSpaceAware` True if the parser is namespace-aware.
`protected boolean`	`isSchemaAware` True if the parser is XML-Schema aware.
`protected boolean`	`isShowingExceptions` True if the parser should show exceptions.
`protected boolean`	`isShowingWarnings` True if the parser should show warnings.
`protected boolean`	`isValidating` True if the parser is validating.
`protected boolean`	`keepPrefixes` True if the parser keep the prefixes.
`protected Map<String,Object>`	`properties` The properties of the parser.
`protected String`	`publicID` The public ID used to validate the parsing.
`protected EntityListResolver`	`resolver` The associated entity list resolver.
`protected URL`	`schemaURL` The URL of the schema used for parsing the content, if a Schema is used for the parsing.

Fields inherited from interface org.mdiutil.xml.InputSourceCaching
CACHING_DEFAULT, CACHING_SOURCES, NOT_CACHING_SOURCES

Constructor Summary

Constructors
Constructor and Description
`XMLSAXParser()` Create a new non validating XML SAX Parser.
`XMLSAXParser(boolean isValidating)` Create a new XML SAX Parser.
`XMLSAXParser(ResolverSAXHandler handler)` Create a new non validating XML SAX Parser.
`XMLSAXParser(String errorTitle)` Create a new non validating XML SAX Parser.
`XMLSAXParser(String errorTitle, boolean isValidating)` Create a new XML SAX Parser.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`allowSchemaValidation(boolean isSchemaAware)` Set if the parser allow a Schema validation.
`protected boolean`	`configureParser(SAXParserFactory fac, InputSource source)` Configure the parser and validate an XML source if a Schema URL has been provided.
`protected boolean`	`configureSchemaValidation(SAXParserFactory factory)` Configure the features of the SAX parser factory for validation.
`Charset`	`getCharset()` Return the charset.
`ClassLoader`	`getClassLoader()` Return the ClassLoader.
`URL`	`getDefaultBaseDirectory()` Return the default base directory which will be used for relative URLs if the parent URL is unknown.
`String`	`getEncoding()` Return the encoding (can be null if not set).
`ParserExceptionListener`	`getExceptionListener()` Return the listener which will be fired if exceptions (including SAXExceptions) are encountered during the parsing.
`Map<String,Boolean>`	`getFeatures()` Return the parser factory features.
`Throwable`	`getFirstException()` Return the first exception encountered by the parser if it encountered a Java exception during the parsing.
`ResolverSAXHandler`	`getHandler()` Return the SAX Handler used for the parsing.
`short`	`getInputSourceCaching()` Return the InputSources caching behavior.
`Locale`	`getLocale()` Return the locale for SAX and validation error messages.
`URL`	`getParsedURL()` Return the URL which was parsed by this Parser.
`Map<String,Object>`	`getProperties()` Return the parser properties.
`static SAXParserFactory`	`getStaticParserFactory()` Return a static SAX parser factory.
`static SAXParserFactory`	`getStaticParserFactory(ClassLoader loader)` Return a SAX parser factory.
`protected void`	`handleException(String message)` Handle an exception message (not a SAX Exception).
`protected void`	`handleException(String title, Exception e)` Handle an exception (not a SAX Exception).
`void`	`handleSAXExceptions(String title)` Handle the SAX Exceptions resulting from the parsing.
`protected void`	`handleSAXExceptions(String title, List<ResolverSAXHandler.ExceptionResult> results)` Handle the SAX Exceptions resulting from the parsing.
`boolean`	`hasDefaultLSResourceResolver()` Return true if a default LSResourceResolver must be used even if no specific resolver has been set
`boolean`	`hasException()` Return true if the parser encountered a Java exception during the parsing.
`boolean`	`hasSchemaValidator()` Return true if this SAX Parser uses a Schema Validator to validate XML files (true by default).
`boolean`	`hasStoppedParsing()` Return true if the parsing has been stopped by the handler before the end of the XML stream.
`boolean`	`isAllowingInternalReaders()` Return true if internal readers creation are allowed in this parser instance.
`boolean`	`isAllowingNestableConnections()` Return true if nestable connections are allowed (ie, an xml file inside a zip file, for example).
`boolean`	`isConcatenatingIncludes()` Return true if xInclude content must be concatenated.
`static boolean`	`isDefaultAllowingNestableConnections()` Return true if nestable connections are allowed by default (ie, an xml file inside a zip file, for example).
`boolean`	`isKeepingPrefixes()` Return true if the parser must keep the prefixes.
`boolean`	`isNameSpaceAware()` Return true if the parser is namespace-aware.
`static boolean`	`isRevertingOldReaderBehavior()` True if the parser is reverting to the previous reader behavior prior to 1.2.7.
`boolean`	`isShowingExceptions()` Return true if the parser shows the exceptions encountered during the parsing.
`boolean`	`isShowingWarnings()` Return true if the parser shows the warnings encountered during the parsing.
`boolean`	`isValidating()` Return true if the parser is validating.
`boolean`	`isXIncludeAware()` Return true if the parser is XInclude-aware.
`boolean`	`isXIncludeSupported()` Return true if the parser support XInclude.
`void`	`parse(File file)` Parse an XML file.
`void`	`parse(File file, BufferedReaderFactory bufFac)` Parse an XML file.
`void`	`parse(InputStream stream)` Parse an XML file with an input Stream.
`void`	`parse(Reader reader)` Parse an XML file with a Reader.
`void`	`parse(ReaderProvider provider)` Parse an XML file with a ReaderProvider.
`void`	`parse(URL url)` Parse an XML file with an URL.
`void`	`parse(URL url, BufferedReaderFactory bufFac)` Parse an XML file with an URL.
`static void`	`resetSAXParserFactoryImplementation()` Reset the SAXParser factory implementation to the default.
`static void`	`revertOldReaderBehavior(boolean revert)` Revert to the previous reader behavior prior to 1.2.7.
`void`	`setAllowInternalReaders(boolean allowInternalReaders)` Set if internal readers creation are allowed in this parser instance.
`void`	`setAllowNestableConnections(boolean allow)` Set if nestable connections are allowed (ie, an xml file inside a zip file, for example).
`void`	`setClassLoader(ClassLoader loader)` Set the ClassLoader.
`void`	`setConcatenateIncludes(boolean concatenateIncludes)` Set if xInclude content must be concatenated.
`static void`	`setDefaultAllowInternalReaders(boolean allowInternalReaders)` Set if internal readers creation are allowed by default.
`static void`	`setDefaultAllowNestableConnections(boolean allow)` Set if nestable connections are allowed by default (ie, an xml file inside a zip file, for example).
`void`	`setDefaultBaseDirectory(URL baseDir)` Set the default base directory which will be used for relative URLs if the parent URL is unknown.
`static void`	`setDefaultLocale(Locale locale)` Set the default locale for all subsequent SAX and validation error messages.
`void`	`setDefaultLSResourceResolver(boolean hasDefaultLSResolver)` Set if a default LSResourceResolver must be used even if no specific resolver has been set.
`void`	`setEncoding(String encoding)` Set the encoding.
`void`	`setEntityListResolver(EntityListResolver resolver)` Set the EntityListResolver which can manage entity resolution in XML files.
`void`	`setErrorTitle(String errorTitle)` Set the parser error dialog title.
`void`	`setExceptionListener(ParserExceptionListener listener)` Set the listener which will be fired if exceptions (including SAXExceptions) are encountered during the parsing.
`void`	`setFeature(String name, boolean value)` Set a parser factory feature.
`void`	`setFeatures(Map<String,Boolean> features)` Set the parser factory features.
`void`	`setHandler(ResolverSAXHandler handler)` Set the SAX Handler used for the parsing.
`void`	`setHandlerDTD(URL dtd, String publicID)` Set the DTD used to validate the parsing.
`void`	`setInputSourceCaching(short cachingType)` Set the InputSources caching behavior.
`void`	`setKeepPrefixes(boolean keepPrefixes)` Set if the parser must keep the prefixes.
`void`	`setLocale(Locale locale)` Set the locale for SAX and validation error messages.
`void`	`setNameSpaceAware(boolean isNameSpaceAware)` Set if the parser is namespace-aware.
`void`	`setParserConfiguration(XMLParserConfiguration config)` Set the parser configuration.
`void`	`setProperties(Map<String,Object> properties)` Set the parser properties.
`void`	`setProperty(String name, Object value)` Set a parser property.
`static void`	`setSAXParserFactoryImplementation(String factoryClassName)` Set the SAXParser factory implementation.
`void`	`setSchema(URL schemaURL)` Set the optional Schema URL to use for Schema validation.
`void`	`setSchemaValidator(boolean hasSchemaValidator)` Set if this SAX Parser uses a Schema Validator to validate XML files (true by default).
`void`	`setValidating(boolean isValidating)` Set if the parser is validating.
`void`	`setXIncludeAware(boolean xIncludeAware)` Set if the parser is XInclude-aware.
`void`	`showExceptions(boolean isShowingExceptions)` Set if the parser shows the exceptions encountered during the parsing.
`void`	`showWarnings(boolean isShowingWarnings)` Set if the parser shows the warnings encountered during the parsing.
`Object`	`stoppedParsingAdditionalContent()` Return the optional additional content returned while the parsing has been stopped before the end of the XML Stream).

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

- Field Detail
  - handler
```
protected ResolverSAXHandler handler
```
    The associated SAX handler.
  - resolver
```
protected EntityListResolver resolver
```
    The associated entity list resolver.
  - features
```
protected Map<String,Boolean> features
```
    The features of the parser factory.
  - properties
```
protected Map<String,Object> properties
```
    The properties of the parser.
  - hasDefaultLSResolver
```
protected boolean hasDefaultLSResolver
```
    True if a default resource resolver should be set even if no resolver has been specified. The resolver will by default be able to resolve the following resources:
    - http://www.w3.org/2001/xml.xsd
    - http://www.w3.org/2009/01/xml.xsd
    - http://www.w3.org/2007/08/xml.xsd
    - http://www.w3.org/2004/10/xml.xsd
    - http://www.w3.org/2001/03/xml.xsd
    - http://www.w3.org/2001/XMLSchema
  - dtd
```
protected URL dtd
```
    The DTD used to validate the parsing.
  - publicID
```
protected String publicID
```
    The public ID used to validate the parsing.
  - isValidating
```
protected boolean isValidating
```
    True if the parser is validating.
  - isShowingExceptions
```
protected boolean isShowingExceptions
```
    True if the parser should show exceptions.
  - isShowingWarnings
```
protected boolean isShowingWarnings
```
    True if the parser should show warnings.
  - isSchemaAware
```
protected boolean isSchemaAware
```
    True if the parser is XML-Schema aware.
  - DEFAULT_ERROR_TITLE
```
public static final String DEFAULT_ERROR_TITLE
```
    The default error title used for the dialog.
    
    See Also:
    
    Constant Field Values
  - errorTitle
```
protected String errorTitle
```
    The error title.
  - firstException
```
protected Throwable firstException
```
    The first throwable thrown by the parser, if the parsing failed beca use of an exception in the handler. Note that SAXExceptions are handled differently.
  - schemaURL
```
protected URL schemaURL
```
    The URL of the schema used for parsing the content, if a Schema is used for the parsing.
  - isNameSpaceAware
```
protected boolean isNameSpaceAware
```
    True if the parser is namespace-aware.
  - keepPrefixes
```
protected boolean keepPrefixes
```
    True if the parser keep the prefixes.
  - encoding
```
protected String encoding
```
    The encoding. Can be null if it is not forced. It basically call setEncoding(String) on the InputSource.
  - exListener
```
protected ParserExceptionListener exListener
```
    The listener which is fired if exceptions (including SAXExceptions) are encountered during the parsing.
- Constructor Detail
  - XMLSAXParser
```
public XMLSAXParser()
```
    Create a new non validating XML SAX Parser.
  - XMLSAXParser
```
public XMLSAXParser(ResolverSAXHandler handler)
```
    Create a new non validating XML SAX Parser.
    
    Parameters:
    
    handler - the SAX Handler
  - XMLSAXParser
```
public XMLSAXParser(String errorTitle)
```
    Create a new non validating XML SAX Parser. The default title is "Parser Exception".
    
    Parameters:
    
    errorTitle - error title
  - XMLSAXParser
```
public XMLSAXParser(boolean isValidating)
```
    Create a new XML SAX Parser.
    
    Parameters:
    
    isValidating - true if the parser is validating
  - XMLSAXParser
```
public XMLSAXParser(String errorTitle,
                    boolean isValidating)
```
    Create a new XML SAX Parser.
    
    Parameters:
    
    errorTitle - error title
    
    isValidating - true if the parser is validating
- Method Detail
  - setClassLoader
```
public void setClassLoader(ClassLoader loader)
```
    Set the ClassLoader. It will only be used if the isRevertingOldReaderBehavior() is false.
    
    Parameters:
    
    loader - the ClassLoader
  - getClassLoader
```
public ClassLoader getClassLoader()
```
    Return the ClassLoader. It will only be used if the isRevertingOldReaderBehavior() is false.
    
    Returns:
    
    the ClassLoader
  - setDefaultLocale
```
public static void setDefaultLocale(Locale locale)
```
    Set the default locale for all subsequent SAX and validation error messages.
    
    Parameters:
    
    locale - the default locale
  - setLocale
```
public void setLocale(Locale locale)
```
    Set the locale for SAX and validation error messages.
    
    Parameters:
    
    locale - the locale
  - getLocale
```
public Locale getLocale()
```
    Return the locale for SAX and validation error messages.
    
    Returns:
    
    the locale
  - setDefaultLSResourceResolver
```
public void setDefaultLSResourceResolver(boolean hasDefaultLSResolver)
```
    Set if a default LSResourceResolver must be used even if no specific resolver has been set. This resolver will by default be able to resolve the following resources:
    - http://www.w3.org/2001/xml.xsd
    - http://www.w3.org/2009/01/xml.xsd
    - http://www.w3.org/2007/08/xml.xsd
    - http://www.w3.org/2004/10/xml.xsd
    - http://www.w3.org/2001/03/xml.xsd
    - http://www.w3.org/2001/XMLSchema
    Parameters:
    
    hasDefaultLSResolver - true if a default LSResourceResolver must be used even if no specific resolver has been set
    
    See Also:
    
    EntityListResolver
  - hasDefaultLSResourceResolver
```
public boolean hasDefaultLSResourceResolver()
```
    Return true if a default LSResourceResolver must be used even if no specific resolver has been set
    
    Returns:
    
    if a default LSResourceResolver must be used even if no specific resolver has been set
    
    See Also:
    
    setDefaultLSResourceResolver(boolean)
  - setDefaultAllowNestableConnections
```
public static void setDefaultAllowNestableConnections(boolean allow)
```
    Set if nestable connections are allowed by default (ie, an xml file inside a zip file, for example).
    
    Parameters:
    
    allow - true if nestable connections are allowed by default
  - setInputSourceCaching
```
public void setInputSourceCaching(short cachingType)
```
    Set the InputSources caching behavior.
    
    Specified by:
    
    setInputSourceCaching in interface InputSourceCaching
    
    Parameters:
    
    cachingType - the caching type
  - getInputSourceCaching
```
public short getInputSourceCaching()
```
    Return the InputSources caching behavior.
    
    Specified by:
    
    getInputSourceCaching in interface InputSourceCaching
    
    Returns:
    
    the caching type
  - revertOldReaderBehavior
```
public static void revertOldReaderBehavior(boolean revert)
```
    Revert to the previous reader behavior prior to 1.2.7. In this case, the code to get the source to construct the reader for the XML file will be:
```
 Reader reader = new InputStreamReader(url.openStream());
 
```
    As you can see, prior to 1.2.7, the default platform Charset was used (no Charset was specified to decode the file), which could lead to decoding problems in the XML files.
    Parameters:
    
    revert - true to revert to the previous reader behavior prior to 1.2.7
  - setSAXParserFactoryImplementation
```
public static void setSAXParserFactoryImplementation(String factoryClassName)
```
    Set the SAXParser factory implementation.
    
    Parameters:
    
    factoryClassName - the factory class name
  - resetSAXParserFactoryImplementation
```
public static void resetSAXParserFactoryImplementation()
```
    Reset the SAXParser factory implementation to the default.
  - setDefaultAllowInternalReaders
```
public static void setDefaultAllowInternalReaders(boolean allowInternalReaders)
```
    Set if internal readers creation are allowed by default.
    
    Parameters:
    
    allowInternalReaders - true if internal readers creation are allowed by default
  - getStaticParserFactory
```
public static SAXParserFactory getStaticParserFactory()
```
    Return a static SAX parser factory.
    
    Returns:
    
    the SAX Parser factory
  - getStaticParserFactory
```
public static SAXParserFactory getStaticParserFactory(ClassLoader loader)
```
    Return a SAX parser factory.
    
    Parameters:
    
    loader - the class loader
    
    Returns:
    
    the SAX Parser factory
  - setAllowInternalReaders
```
public void setAllowInternalReaders(boolean allowInternalReaders)
```
    Set if internal readers creation are allowed in this parser instance.
    
    Parameters:
    
    allowInternalReaders - true if internal readers creation are allowed in this parser instance.
  - isAllowingInternalReaders
```
public boolean isAllowingInternalReaders()
```
    Return true if internal readers creation are allowed in this parser instance.
    
    Returns:
    
    true if internal readers creation are allowed in this parser instance.
  - isRevertingOldReaderBehavior
```
public static boolean isRevertingOldReaderBehavior()
```
    True if the parser is reverting to the previous reader behavior prior to 1.2.7. In this case, the code to get the source to construct the reader for the XML file will be:
```
 Reader reader = new InputStreamReader(url.openStream());
 
```
    As you can see, prior to 1.2.7, the default platform Charset was used (no Charset was specified to decode the file), which could lead to decoding problems in the XML files.
    Returns:
    
    true if the parser is reverting to the previous reader behavior prior to 1.2.7
  - isDefaultAllowingNestableConnections
```
public static boolean isDefaultAllowingNestableConnections()
```
    Return true if nestable connections are allowed by default (ie, an xml file inside a zip file, for example).
    
    Returns:
    
    true if nestable connections are allowed by default
  - setAllowNestableConnections
```
public void setAllowNestableConnections(boolean allow)
```
    Set if nestable connections are allowed (ie, an xml file inside a zip file, for example).
    
    Parameters:
    
    allow - true if nestable connections are allowed
  - isAllowingNestableConnections
```
public boolean isAllowingNestableConnections()
```
    Return true if nestable connections are allowed (ie, an xml file inside a zip file, for example). Note that by default the result will be set by isDefaultAllowingNestableConnections().
    
    Returns:
    
    true if nestable connections are allowed
  - setSchemaValidator
```
public void setSchemaValidator(boolean hasSchemaValidator)
```
    Set if this SAX Parser uses a Schema Validator to validate XML files (true by default). If this parser does not use an XML Validator, the validation will be performed by using an empty SAX Handler.
    
    Parameters:
    
    hasSchemaValidator - true if this SAX Parser uses a Schema Validator to validate XML files
  - hasSchemaValidator
```
public boolean hasSchemaValidator()
```
    Return true if this SAX Parser uses a Schema Validator to validate XML files (true by default).
    
    Returns:
    
    true if this SAX Parser uses a Schema Validator to validate XML files
  - setEntityListResolver
```
public void setEntityListResolver(EntityListResolver resolver)
```
    Set the EntityListResolver which can manage entity resolution in XML files.
    
    Parameters:
    
    resolver - the resolver
  - setEncoding
```
public void setEncoding(String encoding)
```
    Set the encoding. It will try to get the associated Charset and silently swallow UnsupportedCharsetExceptions thrown by the Charset.forName(encoding) method.
    
    Parameters:
    
    encoding - the encoding
  - getEncoding
```
public String getEncoding()
```
    Return the encoding (can be null if not set).
    
    Returns:
    
    the encoding
  - getCharset
```
public Charset getCharset()
```
    Return the charset. The default value is UTF-8. The Charset will change if the setEncoding(java.lang.String) method has been set.
    
    Returns:
    
    the charset
  - setExceptionListener
```
public void setExceptionListener(ParserExceptionListener listener)
```
    Set the listener which will be fired if exceptions (including SAXExceptions) are encountered during the parsing.
    
    Parameters:
    
    listener - the listener
  - getExceptionListener
```
public ParserExceptionListener getExceptionListener()
```
    Return the listener which will be fired if exceptions (including SAXExceptions) are encountered during the parsing. If the listener is null (no listener), the parser will directlydump the parsing exceptions on the out or err streams.
    
    Returns:
    
    the listener which will be fired if exceptions are encountered during the parsing
  - setErrorTitle
```
public void setErrorTitle(String errorTitle)
```
    Set the parser error dialog title.
    
    Parameters:
    
    errorTitle - the parser error dialog title
  - setParserConfiguration
```
public void setParserConfiguration(XMLParserConfiguration config)
```
    Set the parser configuration. It allows to configure trhe parser using an XMLParserConfiguration rather than specifying separately each of the parsing properties.
    
    Parameters:
    
    config - the parser configuration
  - setFeatures
```
public void setFeatures(Map<String,Boolean> features)
```
    Set the parser factory features.
    
    Parameters:
    
    features - the features
  - setFeature
```
public void setFeature(String name,
                       boolean value)
```
    Set a parser factory feature.
    
    Parameters:
    
    name - the feature name
    
    value - the feature value
  - getFeatures
```
public Map<String,Boolean> getFeatures()
```
    Return the parser factory features.
    
    Returns:
    
    the features
  - setProperty
```
public void setProperty(String name,
                        Object value)
```
    Set a parser property.
    
    Parameters:
    
    name - the property name
    
    value - the property value
  - setProperties
```
public void setProperties(Map<String,Object> properties)
```
    Set the parser properties.
    
    Parameters:
    
    properties - the properties
  - getProperties
```
public Map<String,Object> getProperties()
```
    Return the parser properties.
    
    Returns:
    
    the properties
  - allowSchemaValidation
```
public void allowSchemaValidation(boolean isSchemaAware)
```
    Set if the parser allow a Schema validation.
    
    Parameters:
    
    isSchemaAware - true if the parser allow a Schema validation
  - setValidating
```
public void setValidating(boolean isValidating)
```
    Set if the parser is validating.
    
    Parameters:
    
    isValidating - true if the parser is validating
  - isValidating
```
public boolean isValidating()
```
    Return true if the parser is validating.
    
    Returns:
    
    true if the parser is validating
  - setDefaultBaseDirectory
```
public void setDefaultBaseDirectory(URL baseDir)
```
    Set the default base directory which will be used for relative URLs if the parent URL is unknown. It will be used in the case where XInclude are used and the parsing is performed using a Stream or a Reader.
    
    Parameters:
    
    baseDir - the default base directory
  - getDefaultBaseDirectory
```
public URL getDefaultBaseDirectory()
```
    Return the default base directory which will be used for relative URLs if the parent URL is unknown. It will be used in the case where XInclude are used and the parsing is performed using a Stream or a Reader.
    
    Returns:
    
    the default base directory
  - setSchema
```
public void setSchema(URL schemaURL)
```
    Set the optional Schema URL to use for Schema validation. To use Schema validation, you should:
    - set the allowSchemaValidation(boolean) property to true
    Note that it will also set the allowSchemaValidation(boolean) property to true. Note that you should only specify the Schema if you don't set an EntityResolver. If the XML file use several namespaces (and several Schemas), you should only use an EntityResolver.
    Parameters:
    
    schemaURL - the URL of the Schema
  - showExceptions
```
public void showExceptions(boolean isShowingExceptions)
```
    Set if the parser shows the exceptions encountered during the parsing.
    
    Parameters:
    
    isShowingExceptions - true if the parser shows the exceptions encountered during the parsing
  - showWarnings
```
public void showWarnings(boolean isShowingWarnings)
```
    Set if the parser shows the warnings encountered during the parsing.
    
    Parameters:
    
    isShowingWarnings - true if the parser shows the warnings encountered during the parsing
  - isShowingExceptions
```
public boolean isShowingExceptions()
```
    Return true if the parser shows the exceptions encountered during the parsing.
    
    Returns:
    
    true if the parser shows the exceptions encountered during the parsing
  - isShowingWarnings
```
public boolean isShowingWarnings()
```
    Return true if the parser shows the warnings encountered during the parsing.
    
    Returns:
    
    true if the parser shows the warnings encountered during the parsing
  - setNameSpaceAware
```
public void setNameSpaceAware(boolean isNameSpaceAware)
```
    Set if the parser is namespace-aware.
    
    Parameters:
    
    isNameSpaceAware - true if the parser is namespace-aware
  - isNameSpaceAware
```
public boolean isNameSpaceAware()
```
    Return true if the parser is namespace-aware.
    
    Returns:
    
    true if the parser is namespace-aware
  - setKeepPrefixes
```
public void setKeepPrefixes(boolean keepPrefixes)
```
    Set if the parser must keep the prefixes. It will ot contain attributes used as Namespace declarations (xmlns*) unless the http://xml.org/sax/features/namespace-prefixes feature is set to true (it is false by default).
    
    Parameters:
    
    keepPrefixes - true if the parser must keep the prefixes
  - isKeepingPrefixes
```
public boolean isKeepingPrefixes()
```
    Return true if the parser must keep the prefixes.
    
    Returns:
    
    true if the parser must keep the prefixes
  - setConcatenateIncludes
```
public void setConcatenateIncludes(boolean concatenateIncludes)
```
    Set if xInclude content must be concatenated. This allows to parse a file which does content xInclude children with a parser which does not handle xInclude content directly.
    
    Parameters:
    
    concatenateIncludes - true if xInclude content must be concatenated
  - isConcatenatingIncludes
```
public boolean isConcatenatingIncludes()
```
    Return true if xInclude content must be concatenated. This allows to parse a file which does content xInclude children with a parser which does not handle xInclude content directly.
    
    Returns:
    
    true if xInclude content must be concatenated
  - setXIncludeAware
```
public void setXIncludeAware(boolean xIncludeAware)
```
    Set if the parser is XInclude-aware.
    
    Parameters:
    
    xIncludeAware - true if the parser is XInclude-aware
  - isXIncludeAware
```
public boolean isXIncludeAware()
```
    Return true if the parser is XInclude-aware.
    
    Returns:
    
    true if the parser is XInclude-aware
  - isXIncludeSupported
```
public boolean isXIncludeSupported()
```
    Return true if the parser support XInclude. XInclude is supported if isXIncludeAware() is true and the underlying parser support XInclude. Note that this value will only be valid after the parsing.
    
    Returns:
    
    true if the parser support XInclude
  - setHandler
```
public void setHandler(ResolverSAXHandler handler)
```
    Set the SAX Handler used for the parsing.
    
    Parameters:
    
    handler - the SAX Handler used for the parsing
  - getHandler
```
public ResolverSAXHandler getHandler()
```
    Return the SAX Handler used for the parsing.
    
    Returns:
    
    the SAX Handler used for the parsing
  - setHandlerDTD
```
public void setHandlerDTD(URL dtd,
                          String publicID)
```
    Set the DTD used to validate the parsing.
    
    Parameters:
    
    dtd - the DTD URL
    
    publicID - the DTD public ID
  - hasStoppedParsing
```
public boolean hasStoppedParsing()
```
    Return true if the parsing has been stopped by the handler before the end of the XML stream.
    
    Returns:
    
    true if the parsing has been stopped by the handler before the end of the XML stream
  - stoppedParsingAdditionalContent
```
public Object stoppedParsingAdditionalContent()
```
    Return the optional additional content returned while the parsing has been stopped before the end of the XML Stream). Willbe null except if the handler has sopped the parsing before the end of the XML Stream, and has provided an additional content to the StopParsingException.
    
    Returns:
    
    the optional additional content
  - hasException
```
public boolean hasException()
```
    Return true if the parser encountered a Java exception during the parsing. Note that SAXExceptions are not considered and are handled directly by the handler.
    
    Returns:
    
    true if the parser encountered a Java exception during the parsing
  - getFirstException
```
public Throwable getFirstException()
```
    Return the first exception encountered by the parser if it encountered a Java exception during the parsing. Note that SAXExceptions are not considered and are handled directly by the handler.
    
    Returns:
    
    the first exception encountered by the parser (or null)
  - configureParser
```
protected boolean configureParser(SAXParserFactory fac,
                                  InputSource source)
                           throws ParserConfigurationException,
                                  SAXException,
                                  IOException
```
    Configure the parser and validate an XML source if a Schema URL has been provided.
    
    Parameters:
    
    fac - the parser factory
    
    source - the XML source
    
    Returns:
    
    true if the XML source has been validated against the provided Schema
    
    Throws:
    
    ParserConfigurationException
    
    SAXException
    
    IOException
  - configureSchemaValidation
```
protected boolean configureSchemaValidation(SAXParserFactory factory)
                                     throws ParserConfigurationException,
                                            SAXException
```
    Configure the features of the SAX parser factory for validation. The features allow thr parser:
    - To take into account manespace declarations
    - To not add xml:base declarations (fixup-base-uris) which would normally fail Schema processing
    - To not add xml:lang declarations (fixup-language) which would normally fail Schema processing
    - To add schema validation (only if we have defined an external Schema)
    Parameters:
    
    factory - the SAX parser factory
    
    Returns:
    
    true if XInclude is supported
    
    Throws:
    
    ParserConfigurationException
    
    SAXException
  - getParsedURL
```
public URL getParsedURL()
```
    Return the URL which was parsed by this Parser. Note that the result can be null if the parser was called with a parse(java.io.InputStream).
    
    Returns:
    
    the URL which was parsed by this Parser
  - parse
```
public void parse(InputStream stream)
```
    Parse an XML file with an input Stream.
    
    Parameters:
    
    stream - the input Stream
  - parse
```
public void parse(File file)
```
    Parse an XML file. Note that the parser will do nothing if the file is null.
    
    Parameters:
    
    file - the file to parse
  - parse
```
public void parse(File file,
                  BufferedReaderFactory bufFac)
```
    Parse an XML file. Note that the parser will do nothing if the file is null. Passing a BufferedReaderFactory to the method allows to perform filtering on the XML content before passing it to the parser.
    
    Parameters:
    
    file - the file to parse
    
    bufFac - the BufferedReaderFactory to create readers (can be null)
  - parse
```
public void parse(ReaderProvider provider)
```
    Parse an XML file with a ReaderProvider. Contrary to the parse(java.io.Reader), the method allows to reuse the same provider for the Schema validation phase and the parsing phase.
    
    Parameters:
    
    provider - the ReaderProvider
  - parse
```
public void parse(Reader reader)
```
    Parse an XML file with a Reader. Note that the parser will do nothing if the reader is null. Also note that this method will not validate the parsing when using a Schema. The reason is that reader may not be reused again (in our case after the Schema validation phase). In this use case, use instead the parse(org.mdiutil.io.ReaderProvider) method.
    
    Parameters:
    
    reader - the Reader to parse
  - parse
```
public void parse(URL url)
```
    Parse an XML file with an URL. Note taht the parser will do nothing if the URL is null.
    
    Parameters:
    
    url - the URL to parse
  - parse
```
public void parse(URL url,
                  BufferedReaderFactory bufFac)
```
    Parse an XML file with an URL. Note that the parser will do nothing if the URL is null. Passing a BufferedReaderFactory to the method allows to perform filtering on the XML content before passing it to the parser.
    
    Parameters:
    
    url - the URL to parse
    
    bufFac - the BufferedReaderFactory to create readers (can be null)
  - handleException
```
protected void handleException(String message)
```
    Handle an exception message (not a SAX Exception). The handling will be delegated to the ParserExceptionListener if onewas provided to this parser.
    
    Parameters:
    
    message - the exception message
  - handleException
```
protected void handleException(String title,
                               Exception e)
```
    Handle an exception (not a SAX Exception). The handling will be delegated to the ParserExceptionListener if one was provided to this parser.
    
    Parameters:
    
    title - the exception title
    
    e - the Exception
  - handleSAXExceptions
```
public void handleSAXExceptions(String title)
```
    Handle the SAX Exceptions resulting from the parsing. By default it will trigger the ParserExceptionListener with an empty list of exceptions.
    
    Parameters:
    
    title - the title
    
    See Also:
    
    getExceptionListener()
  - handleSAXExceptions
```
protected void handleSAXExceptions(String title,
                                   List<ResolverSAXHandler.ExceptionResult> results)
```
    Handle the SAX Exceptions resulting from the parsing.
    
    Parameters:
    
    title - the title
    
    results - the Exceptions results

Class XMLSAXParser

Examples

Create a validating parser using a DTD

Create a validating parser using a Schema

Create a validating parser and get the parsing exceptions

Field Summary

Fields inherited from interface org.mdiutil.xml.InputSourceCaching

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

handler

resolver

features

properties

hasDefaultLSResolver

dtd

publicID

isValidating

isShowingExceptions

isShowingWarnings

isSchemaAware

DEFAULT_ERROR_TITLE

errorTitle

firstException

schemaURL

isNameSpaceAware

keepPrefixes

encoding

exListener

Constructor Detail

XMLSAXParser

XMLSAXParser

XMLSAXParser

XMLSAXParser

XMLSAXParser

Method Detail

setClassLoader

getClassLoader

setDefaultLocale

setLocale

getLocale

setDefaultLSResourceResolver

hasDefaultLSResourceResolver

setDefaultAllowNestableConnections

setInputSourceCaching

getInputSourceCaching

revertOldReaderBehavior

setSAXParserFactoryImplementation

resetSAXParserFactoryImplementation

setDefaultAllowInternalReaders

getStaticParserFactory

getStaticParserFactory

setAllowInternalReaders

isAllowingInternalReaders

isRevertingOldReaderBehavior

isDefaultAllowingNestableConnections

setAllowNestableConnections

isAllowingNestableConnections

setSchemaValidator

hasSchemaValidator

setEntityListResolver

setEncoding

getEncoding

getCharset

setExceptionListener

getExceptionListener

setErrorTitle

setParserConfiguration

setFeatures

setFeature

getFeatures

setProperty

setProperties

getProperties

allowSchemaValidation

setValidating

isValidating

setDefaultBaseDirectory

getDefaultBaseDirectory