1. // SAX parser interface.

  2. // No warranty; no copyright -- use this as you will.

  3. // $Id: Parser.java,v 1.1 2001/05/20 03:12:56 curcuru Exp $

  4. 

  5. package org.xml.sax;

  6. 

  7. import java.io.IOException;

  8. import java.util.Locale;

  9. 

  10. 

  11. /**

  12.  * Basic interface for SAX (Simple API for XML) parsers.

  13.  *

  14.  * <blockquote>

  15.  * <em>This module, both source code and documentation, is in the

  16.  * Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>

  17.  * </blockquote>

  18.  *

  19.  * <p>This was the main event supplier interface for SAX1; it has

  20.  * been replaced in SAX2 by {@link org.xml.sax.XMLReader XMLReader},

  21.  * which includes Namespace support and sophisticated configurability

  22.  * and extensibility.</p>

  23.  *

  24.  * <p>All SAX1 parsers must implement this basic interface: it allows

  25.  * applications to register handlers for different types of events

  26.  * and to initiate a parse from a URI, or a character stream.</p>

  27.  *

  28.  * <p>All SAX1 parsers must also implement a zero-argument constructor

  29.  * (though other constructors are also allowed).</p>

  30.  *

  31.  * <p>SAX1 parsers are reusable but not re-entrant: the application

  32.  * may reuse a parser object (possibly with a different input source)

  33.  * once the first parse has completed successfully, but it may not

  34.  * invoke the parse() methods recursively within a parse.</p>

  35.  *

  36.  * @deprecated This interface has been replaced by the SAX2

  37.  *             {@link org.xml.sax.XMLReader XMLReader}

  38.  *             interface, which includes Namespace support.

  39.  * @since SAX 1.0

  40.  * @author David Megginson, 

  41.  *         <a href="mailto:sax@megginson.com">sax@megginson.com</a>

  42.  * @version 2.0r2pre

  43.  * @see org.xml.sax.EntityResolver

  44.  * @see org.xml.sax.DTDHandler

  45.  * @see org.xml.sax.DocumentHandler

  46.  * @see org.xml.sax.ErrorHandler

  47.  * @see org.xml.sax.HandlerBase

  48.  * @see org.xml.sax.InputSource

  49.  */

  50. public interface Parser 

  51. {

  52.     

  53.     /**

  54.      * Allow an application to request a locale for errors and warnings.

  55.      *

  56.      * <p>SAX parsers are not required to provide localisation for errors

  57.      * and warnings; if they cannot support the requested locale,

  58.      * however, they must throw a SAX exception.  Applications may

  59.      * not request a locale change in the middle of a parse.</p>

  60.      *

  61.      * @param locale A Java Locale object.

  62.      * @exception org.xml.sax.SAXException Throws an exception

  63.      *            (using the previous or default locale) if the 

  64.      *            requested locale is not supported.

  65.      * @see org.xml.sax.SAXException

  66.      * @see org.xml.sax.SAXParseException

  67.      */

  68.     public abstract void setLocale (Locale locale)

  69. 	throws SAXException;

  70.     

  71.     

  72.     /**

  73.      * Allow an application to register a custom entity resolver.

  74.      *

  75.      * <p>If the application does not register an entity resolver, the

  76.      * SAX parser will resolve system identifiers and open connections

  77.      * to entities itself (this is the default behaviour implemented in

  78.      * HandlerBase).</p>

  79.      *

  80.      * <p>Applications may register a new or different entity resolver

  81.      * in the middle of a parse, and the SAX parser must begin using

  82.      * the new resolver immediately.</p>

  83.      *

  84.      * @param resolver The object for resolving entities.

  85.      * @see EntityResolver

  86.      * @see HandlerBase

  87.      */

  88.     public abstract void setEntityResolver (EntityResolver resolver);

  89.     

  90.     

  91.     /**

  92.      * Allow an application to register a DTD event handler.

  93.      *

  94.      * <p>If the application does not register a DTD handler, all DTD

  95.      * events reported by the SAX parser will be silently

  96.      * ignored (this is the default behaviour implemented by

  97.      * HandlerBase).</p>

  98.      *

  99.      * <p>Applications may register a new or different

  100.      * handler in the middle of a parse, and the SAX parser must

  101.      * begin using the new handler immediately.</p>

  102.      *

  103.      * @param handler The DTD handler.

  104.      * @see DTDHandler

  105.      * @see HandlerBase

  106.      */

  107.     public abstract void setDTDHandler (DTDHandler handler);

  108.     

  109.     

  110.     /**

  111.      * Allow an application to register a document event handler.

  112.      *

  113.      * <p>If the application does not register a document handler, all

  114.      * document events reported by the SAX parser will be silently

  115.      * ignored (this is the default behaviour implemented by

  116.      * HandlerBase).</p>

  117.      *

  118.      * <p>Applications may register a new or different handler in the

  119.      * middle of a parse, and the SAX parser must begin using the new

  120.      * handler immediately.</p>

  121.      *

  122.      * @param handler The document handler.

  123.      * @see DocumentHandler

  124.      * @see HandlerBase

  125.      */

  126.     public abstract void setDocumentHandler (DocumentHandler handler);

  127.     

  128.     

  129.     /**

  130.      * Allow an application to register an error event handler.

  131.      *

  132.      * <p>If the application does not register an error event handler,

  133.      * all error events reported by the SAX parser will be silently

  134.      * ignored, except for fatalError, which will throw a SAXException

  135.      * (this is the default behaviour implemented by HandlerBase).</p>

  136.      *

  137.      * <p>Applications may register a new or different handler in the

  138.      * middle of a parse, and the SAX parser must begin using the new

  139.      * handler immediately.</p>

  140.      *

  141.      * @param handler The error handler.

  142.      * @see ErrorHandler

  143.      * @see SAXException

  144.      * @see HandlerBase

  145.      */

  146.     public abstract void setErrorHandler (ErrorHandler handler);

  147.     

  148.     

  149.     /**

  150.      * Parse an XML document.

  151.      *

  152.      * <p>The application can use this method to instruct the SAX parser

  153.      * to begin parsing an XML document from any valid input

  154.      * source (a character stream, a byte stream, or a URI).</p>

  155.      *

  156.      * <p>Applications may not invoke this method while a parse is in

  157.      * progress (they should create a new Parser instead for each

  158.      * additional XML document).  Once a parse is complete, an

  159.      * application may reuse the same Parser object, possibly with a

  160.      * different input source.</p>

  161.      *

  162.      * @param source The input source for the top-level of the

  163.      *        XML document.

  164.      * @exception org.xml.sax.SAXException Any SAX exception, possibly

  165.      *            wrapping another exception.

  166.      * @exception java.io.IOException An IO exception from the parser,

  167.      *            possibly from a byte stream or character stream

  168.      *            supplied by the application.

  169.      * @see org.xml.sax.InputSource

  170.      * @see #parse(java.lang.String)

  171.      * @see #setEntityResolver

  172.      * @see #setDTDHandler

  173.      * @see #setDocumentHandler

  174.      * @see #setErrorHandler

  175.      */

  176.     public abstract void parse (InputSource source)

  177. 	throws SAXException, IOException;

  178.     

  179.     

  180.     /**

  181.      * Parse an XML document from a system identifier (URI).

  182.      *

  183.      * <p>This method is a shortcut for the common case of reading a

  184.      * document from a system identifier.  It is the exact

  185.      * equivalent of the following:</p>

  186.      *

  187.      * <pre>

  188.      * parse(new InputSource(systemId));

  189.      * </pre>

  190.      *

  191.      * <p>If the system identifier is a URL, it must be fully resolved

  192.      * by the application before it is passed to the parser.</p>

  193.      *

  194.      * @param systemId The system identifier (URI).

  195.      * @exception org.xml.sax.SAXException Any SAX exception, possibly

  196.      *            wrapping another exception.

  197.      * @exception java.io.IOException An IO exception from the parser,

  198.      *            possibly from a byte stream or character stream

  199.      *            supplied by the application.

  200.      * @see #parse(org.xml.sax.InputSource)

  201.      */

  202.     public abstract void parse (String systemId)

  203. 	throws SAXException, IOException;

  204.     

  205. }

  206. 

  207. // end of Parser.java