DefaultHandler.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:28k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: DefaultHandler.hpp,v $
  58.  * Revision 1.5  2002/11/04 14:55:45  tng
  59.  * C++ Namespace Support.
  60.  *
  61.  * Revision 1.4  2002/08/20 16:53:56  tng
  62.  * [Bug 6251] Info during compilation.
  63.  *
  64.  * Revision 1.3  2002/06/06 20:38:45  tng
  65.  * Document Fix: document that the returned object from resolveEntity is owned by the parser
  66.  *
  67.  * Revision 1.2  2002/02/20 18:17:02  tng
  68.  * [Bug 5977] Warnings on generating apiDocs.
  69.  *
  70.  * Revision 1.1.1.1  2002/02/01 22:22:09  peiyongz
  71.  * sane_include
  72.  *
  73.  * Revision 1.6  2002/01/28 17:08:33  knoaman
  74.  * SAX2-ext's DeclHandler support.
  75.  *
  76.  * Revision 1.5  2001/11/13 13:24:05  tng
  77.  * Fix documentation for DefaultHandler.
  78.  *
  79.  * Revision 1.4  2000/12/22 15:17:01  tng
  80.  * SAX2-ext's LexicalHandler support added by David Bertoni.
  81.  *
  82.  * Revision 1.3  2000/08/14 18:56:14  aruna1
  83.  * Virtual parameter inconsistency fixed
  84.  *
  85.  * Revision 1.2  2000/08/07 18:21:27  jpolast
  86.  * change SAX_EXPORT module to SAX2_EXPORT
  87.  *
  88.  * Revision 1.1  2000/08/02 18:02:34  jpolast
  89.  * initial checkin of sax2 implementation
  90.  * submitted by Simon Fell (simon@fell.com)
  91.  * and Joe Polastre (jpolast@apache.org)
  92.  *
  93.  *
  94.  */
  95. #ifndef DEFAULTHANDLER_HPP
  96. #define DEFAULTHANDLER_HPP
  97. #include <xercesc/sax2/ContentHandler.hpp>
  98. #include <xercesc/sax2/LexicalHandler.hpp>
  99. #include <xercesc/sax2/DeclHandler.hpp>
  100. #include <xercesc/sax/DTDHandler.hpp>
  101. #include <xercesc/sax/EntityResolver.hpp>
  102. #include <xercesc/sax/ErrorHandler.hpp>
  103. #include <xercesc/sax/SAXParseException.hpp>
  104. XERCES_CPP_NAMESPACE_BEGIN
  105. class Locator;
  106. class Attributes;
  107. /**
  108.   * Default base class for SAX2 handlers.
  109.   *
  110.   * <p>This class implements the default behaviour for SAX2
  111.   * interfaces: EntityResolver, DTDHandler, ContentHandler,
  112.   * ErrorHandler, LexicalHandler, and DeclHandler.</p>
  113.   *
  114.   * <p>Application writers can extend this class when they need to
  115.   * implement only part of an interface; parser writers can
  116.   * instantiate this class to provide default handlers when the
  117.   * application has not supplied its own.</p>
  118.   *
  119.   * <p>Note that the use of this class is optional.</p>
  120.   *
  121.   * @see EntityResolver#EntityResolver
  122.   * @see DTDHandler#DTDHandler
  123.   * @see ContentHandler#ContentHandler
  124.   * @see ErrorHandler#ErrorHandler
  125.   * @see LexicalHandler#LexicalHandler
  126.   * @see DeclHandler#DeclHandler
  127.   */
  128. class SAX2_EXPORT DefaultHandler :
  129.     public EntityResolver,
  130. public DTDHandler,
  131. public ContentHandler,
  132.     public ErrorHandler,
  133.     public LexicalHandler,
  134.     public DeclHandler
  135. {
  136. public:
  137.   /** @name Default handlers for the DocumentHandler interface */
  138.     //@{
  139.   /**
  140.     * Receive notification of character data inside an element.
  141.     *
  142.     * <p>By default, do nothing.  Application writers may override this
  143.     * method to take specific actions for each chunk of character data
  144.     * (such as adding the data to a node or buffer, or printing it to
  145.     * a file).</p>
  146.     *
  147.     * @param chars The characters.
  148.     * @param length The number of characters to use from the
  149.     *               character array.
  150.     * @exception SAXException Any SAX exception, possibly
  151.     *            wrapping another exception.
  152.     * @see DocumentHandler#characters
  153.     */
  154.     virtual void characters
  155.     (
  156.         const   XMLCh* const    chars
  157.         , const unsigned int    length
  158.     );
  159.   /**
  160.     * Receive notification of the end of the document.
  161.     *
  162.     * <p>By default, do nothing.  Application writers may override this
  163.     * method in a subclass to take specific actions at the beginning
  164.     * of a document (such as finalising a tree or closing an output
  165.     * file).</p>
  166.     *
  167.     * @exception SAXException Any SAX exception, possibly
  168.     *            wrapping another exception.
  169.     * @see DocumentHandler#endDocument
  170.     */
  171.     virtual void endDocument();
  172.   /**
  173.     * Receive notification of the end of an element.
  174.     *
  175.     * <p>By default, do nothing.  Application writers may override this
  176.     * method in a subclass to take specific actions at the end of
  177.     * each element (such as finalising a tree node or writing
  178.     * output to a file).</p>
  179.     *
  180.     * @param uri The URI of the asscioated namespace for this element
  181. * @param localname The local part of the element name
  182. * @param qname The QName of this element
  183.     * @exception SAXException Any SAX exception, possibly
  184.     *            wrapping another exception.
  185.     * @see DocumentHandler#endElement
  186.     */
  187.     virtual void endElement
  188. (
  189. const XMLCh* const uri,
  190. const XMLCh* const localname,
  191. const XMLCh* const qname
  192. );
  193.   /**
  194.     * Receive notification of ignorable whitespace in element content.
  195.     *
  196.     * <p>By default, do nothing.  Application writers may override this
  197.     * method to take specific actions for each chunk of ignorable
  198.     * whitespace (such as adding data to a node or buffer, or printing
  199.     * it to a file).</p>
  200.     *
  201.     * @param chars The whitespace characters.
  202.     * @param length The number of characters to use from the
  203.     *               character array.
  204.     * @exception SAXException Any SAX exception, possibly
  205.     *            wrapping another exception.
  206.     * @see DocumentHandler#ignorableWhitespace
  207.     */
  208.     virtual void ignorableWhitespace
  209.     (
  210.         const   XMLCh* const    chars
  211.         , const unsigned int    length
  212.     );
  213.   /**
  214.     * Receive notification of a processing instruction.
  215.     *
  216.     * <p>By default, do nothing.  Application writers may override this
  217.     * method in a subclass to take specific actions for each
  218.     * processing instruction, such as setting status variables or
  219.     * invoking other methods.</p>
  220.     *
  221.     * @param target The processing instruction target.
  222.     * @param data The processing instruction data, or null if
  223.     *             none is supplied.
  224.     * @exception SAXException Any SAX exception, possibly
  225.     *            wrapping another exception.
  226.     * @see DocumentHandler#processingInstruction
  227.     */
  228.     virtual void processingInstruction
  229.     (
  230.         const   XMLCh* const    target
  231.         , const XMLCh* const    data
  232.     );
  233.     /**
  234.     * Reset the Docuemnt object on its reuse
  235.     *
  236.     * @see DocumentHandler#resetDocument
  237.     */
  238.     virtual void resetDocument();
  239.     //@}
  240.     /** @name Default implementation of DocumentHandler interface */
  241.     //@{
  242.   /**
  243.     * Receive a Locator object for document events.
  244.     *
  245.     * <p>By default, do nothing.  Application writers may override this
  246.     * method in a subclass if they wish to store the locator for use
  247.     * with other document events.</p>
  248.     *
  249.     * @param locator A locator for all SAX document events.
  250.     * @see DocumentHandler#setDocumentLocator
  251.     * @see Locator
  252.     */
  253.     virtual void setDocumentLocator(const Locator* const locator);
  254.   /**
  255.     * Receive notification of the beginning of the document.
  256.     *
  257.     * <p>By default, do nothing.  Application writers may override this
  258.     * method in a subclass to take specific actions at the beginning
  259.     * of a document (such as allocating the root node of a tree or
  260.     * creating an output file).</p>
  261.     *
  262.     * @exception SAXException Any SAX exception, possibly
  263.     *            wrapping another exception.
  264.     * @see DocumentHandler#startDocument
  265.     */
  266.     virtual void startDocument();
  267.   /**
  268.     * Receive notification of the start of an element.
  269.     *
  270.     * <p>By default, do nothing.  Application writers may override this
  271.     * method in a subclass to take specific actions at the start of
  272.     * each element (such as allocating a new tree node or writing
  273.     * output to a file).</p>
  274.     *
  275.     * @param uri The URI of the asscioated namespace for this element
  276. * @param localname the local part of the element name
  277. * @param qname the QName of this element
  278.     * @param attrs The specified or defaulted attributes.
  279.     * @exception SAXException Any SAX exception, possibly
  280.     *            wrapping another exception.
  281.     * @see DocumentHandler#startElement
  282.     */
  283.     virtual void startElement
  284.     (
  285.         const   XMLCh* const    uri,
  286.         const   XMLCh* const    localname,
  287.         const   XMLCh* const    qname
  288.         , const Attributes& attrs
  289.     );
  290.   /**
  291.     * Receive notification of the start of an namespace prefix mapping.
  292.     *
  293.     * <p>By default, do nothing.  Application writers may override this
  294.     * method in a subclass to take specific actions at the start of
  295.     * each namespace prefix mapping.</p>
  296.     *
  297. * NOTE : The current Implementation of SAX2Parser will _NEVER_ call this
  298. *
  299.     * @param prefix The namespace prefix used
  300.     * @param uri The namespace URI used.
  301.     * @exception SAXException Any SAX exception, possibly
  302.     *            wrapping another exception.
  303.     * @see DocumentHandler#startPrefixMapping
  304.     */
  305. virtual void startPrefixMapping
  306. (
  307. const XMLCh* const prefix,
  308. const XMLCh* const uri
  309. ) ;
  310.   /**
  311.     * Receive notification of the end of an namespace prefix mapping.
  312.     *
  313.     * <p>By default, do nothing.  Application writers may override this
  314.     * method in a subclass to take specific actions at the end of
  315.     * each namespace prefix mapping.</p>
  316.     *
  317. * NOTE : The current Implementation of SAX2Parser will _NEVER_ call this
  318. *
  319.     * @param prefix The namespace prefix used
  320.     * @exception SAXException Any SAX exception, possibly
  321.     *            wrapping another exception.
  322.     * @see DocumentHandler#endPrefixMapping
  323.     */
  324. virtual void endPrefixMapping
  325. (
  326. const XMLCh* const prefix
  327. ) ;
  328.   /**
  329.     * Receive notification of a skipped entity
  330.     *
  331.     * <p>The parser will invoke this method once for each entity
  332. * skipped.  All processors may skip external entities,
  333. * depending on the values of the features:<br>
  334. * http://xml.org/sax/features/external-general-entities<br>
  335. * http://xml.org/sax/features/external-parameter-entities</p>
  336.     *
  337. * <p>Introduced with SAX2</p>
  338. *
  339.     * @param name The name of the skipped entity.  If it is a parameter entity,
  340. * the name will begin with %, and if it is the external DTD subset,
  341. * it will be the string [dtd].
  342.     * @exception SAXException Any SAX exception, possibly
  343.     *            wrapping another exception.
  344.     */
  345. virtual void skippedEntity
  346. (
  347. const XMLCh* const name
  348. ) ;
  349.     //@}
  350.     /** @name Default implementation of the EntityResolver interface. */
  351.     //@{
  352.   /**
  353.     * Resolve an external entity.
  354.     *
  355.     * <p>Always return null, so that the parser will use the system
  356.     * identifier provided in the XML document.  This method implements
  357.     * the SAX default behaviour: application writers can override it
  358.     * in a subclass to do special translations such as catalog lookups
  359.     * or URI redirection.</p>
  360.     *
  361.     * @param publicId The public identifer, or null if none is
  362.     *                 available.
  363.     * @param systemId The system identifier provided in the XML
  364.     *                 document.
  365.     * @return The new input source, or null to require the
  366.     *         default behaviour.
  367.     *         The returned InputSource is owned by the parser which is
  368.     *         responsible to clean up the memory.
  369.     * @exception SAXException Any SAX exception, possibly
  370.     *            wrapping another exception.
  371.     * @see EntityResolver#resolveEntity
  372.     */
  373.     virtual InputSource* resolveEntity
  374.     (
  375.         const   XMLCh* const    publicId
  376.         , const XMLCh* const    systemId
  377.     );
  378.     //@}
  379.     /** @name Default implementation of the ErrorHandler interface */
  380.     //@{
  381.    /**
  382.     * Receive notification of a recoverable parser error.
  383.     *
  384.     * <p>The default implementation does nothing.  Application writers
  385.     * may override this method in a subclass to take specific actions
  386.     * for each error, such as inserting the message in a log file or
  387.     * printing it to the console.</p>
  388.     *
  389.     * @param exception The warning information encoded as an exception.
  390.     * @exception SAXException Any SAX exception, possibly
  391.     *            wrapping another exception.
  392.     * @see ErrorHandler#warning
  393.     * @see SAXParseException#SAXParseException
  394.     */
  395.     virtual void error(const SAXParseException& exception);
  396.   /**
  397.     * Report a fatal XML parsing error.
  398.     *
  399.     * <p>The default implementation throws a SAXParseException.
  400.     * Application writers may override this method in a subclass if
  401.     * they need to take specific actions for each fatal error (such as
  402.     * collecting all of the errors into a single report): in any case,
  403.     * the application must stop all regular processing when this
  404.     * method is invoked, since the document is no longer reliable, and
  405.     * the parser may no longer report parsing events.</p>
  406.     *
  407.     * @param exception The error information encoded as an exception.
  408.     * @exception SAXException Any SAX exception, possibly
  409.     *            wrapping another exception.
  410.     * @see ErrorHandler#fatalError
  411.     * @see SAXParseException#SAXParseException
  412.     */
  413.     virtual void fatalError(const SAXParseException& exception);
  414.   /**
  415.     * Receive notification of a parser warning.
  416.     *
  417.     * <p>The default implementation does nothing.  Application writers
  418.     * may override this method in a subclass to take specific actions
  419.     * for each warning, such as inserting the message in a log file or
  420.     * printing it to the console.</p>
  421.     *
  422.     * @param exception The warning information encoded as an exception.
  423.     * @exception SAXException Any SAX exception, possibly
  424.     *            wrapping another exception.
  425.     * @see ErrorHandler#warning
  426.     * @see SAXParseException#SAXParseException
  427.     */
  428.     virtual void warning(const SAXParseException& exception);
  429.     /**
  430.     * Reset the Error handler object on its reuse
  431.     *
  432.     * @see ErrorHandler#resetErrors
  433.     */
  434.     virtual void resetErrors();
  435.     //@}
  436.     /** @name Default implementation of DTDHandler interface. */
  437.     //@{
  438.   /**
  439.     * Receive notification of a notation declaration.
  440.     *
  441.     * <p>By default, do nothing.  Application writers may override this
  442.     * method in a subclass if they wish to keep track of the notations
  443.     * declared in a document.</p>
  444.     *
  445.     * @param name The notation name.
  446.     * @param publicId The notation public identifier, or null if not
  447.     *                 available.
  448.     * @param systemId The notation system identifier.
  449.     * @see DTDHandler#notationDecl
  450.     */
  451.     virtual void notationDecl
  452.     (
  453.         const   XMLCh* const    name
  454.         , const XMLCh* const    publicId
  455.         , const XMLCh* const    systemId
  456.     );
  457.     /**
  458.     * Reset the DTD object on its reuse
  459.     *
  460.     * @see DTDHandler#resetDocType
  461.     */
  462.     virtual void resetDocType();
  463.   /**
  464.     * Receive notification of an unparsed entity declaration.
  465.     *
  466.     * <p>By default, do nothing.  Application writers may override this
  467.     * method in a subclass to keep track of the unparsed entities
  468.     * declared in a document.</p>
  469.     *
  470.     * @param name The entity name.
  471.     * @param publicId The entity public identifier, or null if not
  472.     *                 available.
  473.     * @param systemId The entity system identifier.
  474.     * @param notationName The name of the associated notation.
  475.     * @see DTDHandler#unparsedEntityDecl
  476.     */
  477.     virtual void unparsedEntityDecl
  478.     (
  479.         const   XMLCh* const    name
  480.         , const XMLCh* const    publicId
  481.         , const XMLCh* const    systemId
  482.         , const XMLCh* const    notationName
  483.     );
  484.     //@}
  485.     /** @name Default implementation of LexicalHandler interface. */
  486.     //@{
  487.    /**
  488.     * Receive notification of comments.
  489.     *
  490.     * <p>The Parser will call this method to report each occurence of
  491.     * a comment in the XML document.</p>
  492.     *
  493.     * <p>The application must not attempt to read from the array
  494.     * outside of the specified range.</p>
  495.     *
  496.     * @param chars The characters from the XML document.
  497.     * @param length The number of characters to read from the array.
  498.     * @exception SAXException Any SAX exception, possibly
  499.     *            wrapping another exception.
  500.     */
  501.     virtual void comment
  502.     (
  503.         const   XMLCh* const    chars
  504.         , const unsigned int    length
  505.     );
  506.   /**
  507.     * Receive notification of the end of a CDATA section.
  508.     *
  509.     * <p>The SAX parser will invoke this method at the end of
  510.     * each CDATA parsed.</p>
  511.     *
  512.     * @exception SAXException Any SAX exception, possibly
  513.     *            wrapping another exception.
  514.     */
  515.     virtual void endCDATA ();
  516.   /**
  517.     * Receive notification of the end of the DTD declarations.
  518.     *
  519.     * <p>The SAX parser will invoke this method at the end of the
  520.     * DTD</p>
  521.     *
  522.     * @exception SAXException Any SAX exception, possibly
  523.     *            wrapping another exception.
  524.     */
  525.     virtual void endDTD ();
  526.   /**
  527.     * Receive notification of the end of an entity.
  528.     *
  529.     * <p>The SAX parser will invoke this method at the end of an
  530.     * entity</p>
  531.     *
  532.     * @param name The name of the entity that is ending.
  533.     * @exception SAXException Any SAX exception, possibly
  534.     *            wrapping another exception.
  535.     */
  536.     virtual void endEntity (const XMLCh* const name);
  537.   /**
  538.     * Receive notification of the start of a CDATA section.
  539.     *
  540.     * <p>The SAX parser will invoke this method at the start of
  541.     * each CDATA parsed.</p>
  542.     *
  543.     * @exception SAXException Any SAX exception, possibly
  544.     *            wrapping another exception.
  545.     */
  546.     virtual void startCDATA ();
  547.   /**
  548.     * Receive notification of the start of the DTD declarations.
  549.     *
  550.     * <p>The SAX parser will invoke this method at the start of the
  551.     * DTD</p>
  552.     *
  553.     * @param name The document type name.
  554.     * @param publicId The declared public identifier for the external DTD subset, or null if none was declared.
  555.     * @param systemId The declared system identifier for the external DTD subset, or null if none was declared.
  556.     * @exception SAXException Any SAX exception, possibly
  557.     *            wrapping another exception.
  558.     */
  559.     virtual void startDTD
  560.     (
  561.         const   XMLCh* const    name
  562.         , const   XMLCh* const    publicId
  563.         , const   XMLCh* const    systemId
  564.     );
  565.   /**
  566.     * Receive notification of the start of an entity.
  567.     *
  568.     * <p>The SAX parser will invoke this method at the start of an
  569.     * entity</p>
  570.     *
  571.     * @param name The name of the entity that is starting.
  572.     * @exception SAXException Any SAX exception, possibly
  573.     *            wrapping another exception.
  574.     */
  575.     virtual void startEntity (const XMLCh* const name);
  576.     //@}
  577.     /** @name Default implementation of DeclHandler interface. */
  578.     //@{
  579.    /**
  580.     * Report an element type declaration.
  581.     *
  582.     * <p>The content model will consist of the string "EMPTY", the string
  583.     * "ANY", or a parenthesised group, optionally followed by an occurrence
  584.     * indicator. The model will be normalized so that all parameter entities
  585.     * are fully resolved and all whitespace is removed,and will include the
  586.     * enclosing parentheses. Other normalization (such as removing redundant
  587.     * parentheses or simplifying occurrence indicators) is at the discretion
  588.     * of the parser.</p>
  589.     *
  590.     * @param name The element type name.
  591.     * @param model The content model as a normalized string.
  592.     * @exception SAXException Any SAX exception, possibly
  593.     *            wrapping another exception.
  594.     */
  595.     virtual void elementDecl
  596.     (
  597.         const   XMLCh* const    name
  598.         , const XMLCh* const    model
  599.     );
  600.    /**
  601.     * Report an attribute type declaration.
  602.     *
  603.     * <p>Only the effective (first) declaration for an attribute will
  604.     * be reported.</p>
  605.     *
  606.     * @param eName The name of the associated element.
  607.     * @param aName The name of the attribute.
  608.     * @param type A string representing the attribute type.
  609.     * @param mode A string representing the attribute defaulting mode ("#IMPLIED", "#REQUIRED", or "#FIXED") or null if none of these applies.
  610.     * @param value A string representing the attribute's default value, or null if there is none.
  611.     * @exception SAXException Any SAX exception, possibly
  612.     *            wrapping another exception.
  613.     */
  614.     virtual void attributeDecl
  615.     (
  616.         const   XMLCh* const    eName
  617.         , const XMLCh* const    aName
  618.         , const XMLCh* const    type
  619.         , const XMLCh* const    mode
  620.         , const XMLCh* const    value
  621.     );
  622.    /**
  623.     * Report an internal entity declaration.
  624.     *
  625.     * <p>Only the effective (first) declaration for each entity will be
  626.     * reported. All parameter entities in the value will be expanded, but
  627.     * general entities will not.</p>
  628.     *
  629.     * @param name The name of the entity. If it is a parameter entity, the name will begin with '%'.
  630.     * @param value The replacement text of the entity.
  631.     * @exception SAXException Any SAX exception, possibly
  632.     *            wrapping another exception.
  633.     */
  634.     virtual void internalEntityDecl
  635.     (
  636.         const   XMLCh* const    name
  637.         , const XMLCh* const    value
  638.     );
  639.    /**
  640.     * Report a parsed external entity declaration.
  641.     *
  642.     * <p>Only the effective (first) declaration for each entity will
  643.     * be reported.</p>
  644.     *
  645.     * @param name The name of the entity. If it is a parameter entity, the name will begin with '%'.
  646.     * @param publicId The The declared public identifier of the entity, or null if none was declared.
  647.     * @param systemId The declared system identifier of the entity.
  648.     * @exception SAXException Any SAX exception, possibly
  649.     *            wrapping another exception.
  650.     */
  651.     virtual void externalEntityDecl
  652.     (
  653.         const   XMLCh* const    name
  654.         , const XMLCh* const    publicId
  655.         , const XMLCh* const    systemId
  656.     );
  657.     //@}
  658. };
  659. // ---------------------------------------------------------------------------
  660. //  HandlerBase: Inline default implementations
  661. // ---------------------------------------------------------------------------
  662. inline void DefaultHandler::characters(const   XMLCh* const
  663.                                        ,const   unsigned int)
  664. {
  665. }
  666. inline void DefaultHandler::endDocument()
  667. {
  668. }
  669. inline void DefaultHandler::endElement(const XMLCh* const
  670. , const XMLCh* const
  671. , const XMLCh* const)
  672. {
  673. }
  674. inline void DefaultHandler::error(const SAXParseException&)
  675. {
  676. }
  677. inline void DefaultHandler::fatalError(const SAXParseException& exception)
  678. {
  679.     throw exception;
  680. }
  681. inline void
  682. DefaultHandler::ignorableWhitespace( const   XMLCh* const
  683.                                     , const unsigned int)
  684. {
  685. }
  686. inline void DefaultHandler::notationDecl(  const   XMLCh* const
  687. , const XMLCh* const
  688. , const XMLCh* const)
  689. {
  690. }
  691. inline void
  692. DefaultHandler::processingInstruction( const   XMLCh* const
  693. , const XMLCh* const)
  694. {
  695. }
  696. inline void DefaultHandler::resetErrors()
  697. {
  698. }
  699. inline void DefaultHandler::resetDocument()
  700. {
  701. }
  702. inline void DefaultHandler::resetDocType()
  703. {
  704. }
  705. inline InputSource*
  706. DefaultHandler::resolveEntity( const   XMLCh* const
  707. , const XMLCh* const)
  708. {
  709.     return 0;
  710. }
  711. inline void
  712. DefaultHandler::unparsedEntityDecl(const   XMLCh* const
  713. , const XMLCh* const
  714. , const XMLCh* const
  715. , const XMLCh* const)
  716. {
  717. }
  718. inline void DefaultHandler::setDocumentLocator(const Locator* const)
  719. {
  720. }
  721. inline void DefaultHandler::startDocument()
  722. {
  723. }
  724. inline void
  725. DefaultHandler::startElement(  const     XMLCh* const
  726. , const   XMLCh* const
  727. , const   XMLCh* const
  728. , const   Attributes&
  729. )
  730. {
  731. }
  732. inline void DefaultHandler::warning(const SAXParseException&)
  733. {
  734. }
  735. inline void DefaultHandler::startPrefixMapping ( const XMLCh* const
  736. ,const XMLCh* const)
  737. {
  738. }
  739. inline void DefaultHandler::endPrefixMapping ( const XMLCh* const)
  740. {
  741. }
  742. inline void DefaultHandler::skippedEntity ( const XMLCh* const)
  743. {
  744. }
  745. inline void DefaultHandler::comment(  const   XMLCh* const
  746.                                        , const unsigned int)
  747. {
  748. }
  749. inline void DefaultHandler::endCDATA ()
  750. {
  751. }
  752. inline void DefaultHandler::endDTD ()
  753. {
  754. }
  755. inline void DefaultHandler::endEntity (const XMLCh* const)
  756. {
  757. }
  758. inline void DefaultHandler::startCDATA ()
  759. {
  760. }
  761. inline void DefaultHandler::startDTD(  const   XMLCh* const
  762.                                         , const   XMLCh* const
  763.                                         , const   XMLCh* const)
  764. {
  765. }
  766. inline void DefaultHandler::startEntity (const XMLCh* const)
  767. {
  768. }
  769. inline void DefaultHandler::attributeDecl(const XMLCh* const,
  770.                                           const XMLCh* const,
  771.                                           const XMLCh* const,
  772.                                           const XMLCh* const,
  773.                                           const XMLCh* const)
  774. {
  775. }
  776. inline void DefaultHandler::elementDecl(const XMLCh* const,
  777.                                         const XMLCh* const)
  778. {
  779. }
  780. inline void DefaultHandler::externalEntityDecl(const XMLCh* const,
  781.                                                const XMLCh* const,
  782.                                                const XMLCh* const)
  783. {
  784. }
  785. inline void DefaultHandler::internalEntityDecl(const XMLCh* const,
  786.                                                const XMLCh* const)
  787. {
  788. }
  789. XERCES_CPP_NAMESPACE_END
  790. #endif // ! DEFAULTHANDLER_HPP