converterparser.java

来自「swing编写的库存管理程序。毕业设计类」· Java 代码 · 共 536 行 · 第 1/2 页

  }

  /**
   * Receive notification of a recoverable error.
   *
   * <p>This corresponds to the definition of "error" in section 1.2
   * of the W3C XML 1.0 Recommendation.  For example, a validating
   * parser would use this callback to report the violation of a
   * validity constraint.  The default behaviour is to take no
   * action.</p>
   *
   * <p>The SAX parser must continue to provide normal parsing events
   * after invoking this method: it should still be possible for the
   * application to process the document through to the end.  If the
   * application cannot do so, then the parser should report a fatal
   * error even if the XML 1.0 recommendation does not require it to
   * do so.</p>
   *
   * <p>Filters may use this method to report other, non-XML errors
   * as well.</p>
   *
   * @param exception The error information encapsulated in a
   *                  SAX parse exception.
   * @exception SAXException Any SAX exception, possibly
   *            wrapping another exception.
   * @see SAXParseException
   */
  public void error(final SAXParseException exception)
      throws SAXException
  {
    base.error(exception);
  }

  /**
   * Receive notification of a non-recoverable error.
   *
   * <p>This corresponds to the definition of "fatal error" in
   * section 1.2 of the W3C XML 1.0 Recommendation.  For example, a
   * parser would use this callback to report the violation of a
   * well-formedness constraint.</p>
   *
   * <p>The application must assume that the document is unusable
   * after the parser has invoked this method, and should continue
   * (if at all) only for the sake of collecting addition error
   * messages: in fact, SAX parsers are free to stop reporting any
   * other events once this method has been invoked.</p>
   *
   * @param exception The error information encapsulated in a
   *                  SAX parse exception.
   * @exception SAXException Any SAX exception, possibly
   *            wrapping another exception.
   * @see SAXParseException
   */
  public void fatalError(final SAXParseException exception)
      throws SAXException
  {
    base.fatalError(exception);
  }

  /**
   * Returns a helper object.
   *
   * @param key  the key.
   *
   * @return The object.
   */
  public Object getHelperObject(final String key)
  {
    return base.getHelperObject(key);
  }

  /**
   * Receive an object for locating the origin of SAX document events.
   *
   * The locator allows the application to determine the end position of
   * any document-related event, even if the parser is not reporting an
   * error. Typically, the application will use this information for
   * reporting its own errors (such as character content that does not
   * match an application's business rules). The information returned by
   * the locator is probably not sufficient for use with a search engine.
   *
   * @param locator  the locator.
   */
  public void setDocumentLocator(final Locator locator)
  {
    base.setDocumentLocator(locator);
  }

  /**
   * Returns the current locator.
   *
   * @return the locator.
   */
  public Locator getLocator()
  {
    return base.getLocator();
  }

  /**
   * Pushes a handler onto the stack.
   *
   * @param elementDefinitionHandler  the handler.
   */
  public void pushFactory(final ElementDefinitionHandler elementDefinitionHandler)
  {
    base.pushFactory(elementDefinitionHandler);
  }

  /**
   * Reads a handler off the stack without removing it.
   *
   * @return The handler.
   */
  public ElementDefinitionHandler peekFactory()
  {
    return base.peekFactory();
  }

  /**
   * Pops a handler from the stack.
   *
   * @return The handler.
   */
  public ElementDefinitionHandler popFactory()
  {
    return base.popFactory();
  }

  /**
   * Receive notification of the end of the document.
   * Forwards the event to the base parser implementation.
   *
   * @exception SAXException Any SAX exception, possibly wrapping another exception.
   *
   * @see org.xml.sax.ContentHandler#endDocument
   */
  public void endDocument() throws SAXException
  {
    base.endDocument();
  }

  /**
   * Receive notification of the beginning of the document.
   * Forwards the event to the base parser implementation.
   *
   * @exception SAXException Any SAX exception, possibly wrapping another exception.
   * @see org.xml.sax.ContentHandler#startDocument
   */
  public void startDocument() throws SAXException
  {
    base.startDocument();
  }

  /**
   * Receive notification of character data inside an element.
   * Forwards the event to the base parser implementation.
   *
   * @param chars  the characters.
   * @param start  the start position in the character array.
   * @param length  the number of characters to use from the character array.
   *
   * @exception SAXException Any SAX exception, possibly wrapping another exception.
   * @see org.xml.sax.ContentHandler#characters
   */
  public void characters(final char[] chars, final int start, final int length) throws SAXException
  {
    base.characters(chars, start, length);
  }

  /**
   * Sets the initial handler.
   *
   * @param elementDefinitionHandler  the initial handler.
   */
  public void setInitialFactory(final ElementDefinitionHandler elementDefinitionHandler)
  {
    base.setInitialFactory(elementDefinitionHandler);
  }

  /**
   * Returns the initial handler.
   *
   * @return The initial handler.
   */
  public ElementDefinitionHandler getInitialFactory()
  {
    return base.getInitialFactory();
  }

  /**
   * Returns the configuration property with the specified key.
   *
   * @param key  the property key.
   *
   * @return the property value.
   */
  public String getConfigProperty(final String key)
  {
    return base.getConfigProperty(key);
  }

  /**
   * Returns the configuration property with the specified key (or the specified default value
   * if there is no such property).
   * <p>
   * If the property is not defined in this configuration, the code will lookup the property in
   * the parent configuration.
   *
   * @param key  the property key.
   * @param defaultValue  the default value.
   *
   * @return the property value.
   */
  public String getConfigProperty(final String key, final String defaultValue)
  {
    return base.getConfigProperty(key, defaultValue);
  }

  /**
   * Sets a parser configuration value.
   *
   * @param key  the key.
   * @param value  the value.
   */
  public void setConfigProperty(final String key, final String value)
  {
    base.setConfigProperty(key, value);
  }

  /**
   * Sets a helper object.
   *
   * @param key  the key.
   * @param value  the value.
   */
  public void setHelperObject(final String key, final Object value)
  {
    base.setHelperObject(key, value);
  }

  /**
   * Returns a new instance of the parser.
   *
   * @return a new instance of the parser.
   */
  public Parser getInstance()
  {
    return new ConverterParser(base);
  }

  /**
   * Returns the parsed result object after the parsing is complete. Calling
   * this function during the parsing is undefined and may result in an
   * IllegalStateException.
   * <p>
   * This is a proxy implementation. Forwards all calls to the base parser.
   *
   * @see Parser#getResult
   * @return the result
   */
  public Object getResult()
  {
    return base.getResult();
  }


}