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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2002 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) 2001, 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.  * $Id: DOMBuilderImpl.hpp,v 1.13 2003/05/15 18:26:50 knoaman Exp $
  58.  *
  59.  */
  60. #if !defined(DOMBUILDERIMPL_HPP)
  61. #define DOMBUILDERIMPL_HPP
  62. #include <xercesc/parsers/AbstractDOMParser.hpp>
  63. #include <xercesc/dom/DOMBuilder.hpp>
  64. #include <xercesc/util/XercesDefs.hpp>
  65. XERCES_CPP_NAMESPACE_BEGIN
  66.  /**
  67.   * Introduced in DOM Level 3
  68.   *
  69.   * DOMBuilderImpl provides an implementation of a DOMBuilder interface.
  70.   * A DOMBuilder instance is obtained from the DOMImplementationLS interface
  71.   * by invoking its createDOMBuilder method.
  72.   */
  73. class PARSERS_EXPORT DOMBuilderImpl : public AbstractDOMParser,
  74.                                       public DOMBuilder
  75. {
  76. public :
  77.     // -----------------------------------------------------------------------
  78.     //  Constructors and Detructor
  79.     // -----------------------------------------------------------------------
  80.     /** @name Constructors and Destructor */
  81.     //@{
  82.     /** Construct a DOMBuilderImpl, with an optional validator
  83.       *
  84.       * Constructor with an instance of validator class to use for
  85.       * validation. If you don't provide a validator, a default one will
  86.       * be created for you in the scanner.
  87.       *
  88.       * @param valToAdopt Pointer to the validator instance to use. The
  89.       *                   parser is responsible for freeing the memory.
  90.       */
  91.     DOMBuilderImpl
  92.     (
  93.           XMLValidator* const  valToAdopt = 0
  94.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  95.     );
  96.     /**
  97.       * Destructor
  98.       */
  99.     virtual ~DOMBuilderImpl();
  100.     //@}
  101.     // -----------------------------------------------------------------------
  102.     //  Implementation of DOMBuilder interface
  103.     // -----------------------------------------------------------------------
  104.     // -----------------------------------------------------------------------
  105.     //  Getter methods
  106.     // -----------------------------------------------------------------------
  107.     /** @name Getter methods */
  108.     //@{
  109.     /**
  110.       * <p><b>"Experimental - subject to change"</b></p>
  111.       *
  112.       * Get a pointer to the error handler
  113.       *
  114.       * This method returns the installed error handler. If no handler
  115.       * has been installed, then it will be a zero pointer.
  116.       *
  117.       * @return The pointer to the installed error handler object.
  118.       */
  119.     DOMErrorHandler* getErrorHandler();
  120.     /**
  121.       * <p><b>"Experimental - subject to change"</b></p>
  122.       *
  123.       * Get a const pointer to the error handler
  124.       *
  125.       * This method returns the installed error handler.  If no handler
  126.       * has been installed, then it will be a zero pointer.
  127.       *
  128.       * @return A const pointer to the installed error handler object.
  129.       */
  130.     const DOMErrorHandler* getErrorHandler() const;
  131.     /**
  132.       * <p><b>"Experimental - subject to change"</b></p>
  133.       *
  134.       * Get a pointer to the entity resolver
  135.       *
  136.       * This method returns the installed entity resolver.  If no resolver
  137.       * has been installed, then it will be a zero pointer.
  138.       *
  139.       * @return The pointer to the installed entity resolver object.
  140.       */
  141.     DOMEntityResolver* getEntityResolver();
  142.     /**
  143.       * <p><b>"Experimental - subject to change"</b></p>
  144.       *
  145.       * Get a const pointer to the entity resolver
  146.       *
  147.       * This method returns the installed entity resolver. If no resolver
  148.       * has been installed, then it will be a zero pointer.
  149.       *
  150.       * @return A const pointer to the installed entity resolver object.
  151.       */
  152.     const DOMEntityResolver* getEntityResolver() const;
  153.     /**
  154.       * <p><b>"Experimental - subject to change"</b></p>
  155.       *
  156.       * Get a pointer to the application filter
  157.       *
  158.       * This method returns the installed application filter. If no filter
  159.       * has been installed, then it will be a zero pointer.
  160.       *
  161.       * @return The pointer to the installed application filter.
  162.       */
  163.     DOMBuilderFilter* getFilter();
  164.     /**
  165.       * <p><b>"Experimental - subject to change"</b></p>
  166.       *
  167.       * Get a const pointer to the application filter
  168.       *
  169.       * This method returns the installed application filter. If no filter
  170.       * has been installed, then it will be a zero pointer.
  171.       *
  172.       * @return A const pointer to the installed application filter
  173.       */
  174.     const DOMBuilderFilter* getFilter() const;
  175.     //@}
  176.     // -----------------------------------------------------------------------
  177.     //  Setter methods
  178.     // -----------------------------------------------------------------------
  179.     /** @name Setter methods */
  180.     //@{
  181.     /**
  182.       * <p><b>"Experimental - subject to change"</b></p>
  183.       *
  184.       * Set the error handler
  185.       *
  186.       * This method allows applications to install their own error handler
  187.       * to trap error and warning messages.
  188.       *
  189.       * <i>Any previously set handler is merely dropped, since the parser
  190.       * does not own them.</i>
  191.       *
  192.       * @param handler  A const pointer to the user supplied error
  193.       *                 handler.
  194.       *
  195.       * @see #getErrorHandler
  196.       */
  197.     void setErrorHandler(DOMErrorHandler* const handler);
  198.     /**
  199.       * <p><b>"Experimental - subject to change"</b></p>
  200.       *
  201.       * Set the entity resolver
  202.       *
  203.       * This method allows applications to install their own entity
  204.       * resolver. By installing an entity resolver, the applications
  205.       * can trap and potentially redirect references to external
  206.       * entities.
  207.       *
  208.       * <i>Any previously set resolver is merely dropped, since the parser
  209.       * does not own them.</i>
  210.       *
  211.       * @param handler  A const pointer to the user supplied entity
  212.       *                 resolver.
  213.       *
  214.       * @see #getEntityResolver
  215.       */
  216.     void setEntityResolver(DOMEntityResolver* const handler);
  217.     /**
  218.       * <p><b>"Experimental - subject to change"</b></p>
  219.       *
  220.       * Set the application filter
  221.       *
  222.       * When the application provides a filter, the parser will call out to
  223.       * the filter at the completion of the construction of each Element node.
  224.       * The filter implementation can choose to remove the element from the
  225.       * document being constructed (unless the element is the document element)
  226.       * or to terminate the parse early. If the document is being validated
  227.       * when it's loaded the validation happens before the filter is called.
  228.       *
  229.       * <i>Any previously set filter is merely dropped, since the parser
  230.       * does not own them.</i>
  231.       *
  232.       * @param filter  A const pointer to the user supplied application
  233.       *                filter.
  234.       *
  235.       * @see #getFilter
  236.       */
  237.     void setFilter(DOMBuilderFilter* const filter);
  238.     //@}
  239.     // -----------------------------------------------------------------------
  240.     //  Feature methods
  241.     // -----------------------------------------------------------------------
  242.     /** @name Feature methods */
  243.     //@{
  244.     /**
  245.       * <p><b>"Experimental - subject to change"</b></p>
  246.       *
  247.       * Set the state of a feature
  248.       *
  249.       * It is possible for a DOMBuilder to recognize a feature name but to be
  250.       * unable to set its value.
  251.       *
  252.       * @param name  The feature name.
  253.       * @param state The requested state of the feature (true or false).
  254.       * @exception DOMException
  255.       *     NOT_SUPPORTED_ERR: Raised when the DOMBuilder recognizes the
  256.       *     feature name but cannot set the requested value.
  257.       *     <br>NOT_FOUND_ERR: Raised when the DOMBuilder does not recognize
  258.       *     the feature name.
  259.       *
  260.       * @see #getFeature
  261.       * @see #canSetFeature
  262.       */
  263.     void setFeature(const XMLCh* const name, const bool state);
  264.     /**
  265.       * <p><b>"Experimental - subject to change"</b></p>
  266.       *
  267.       * Look up the value of a feature.
  268.       *
  269.       * @param name The feature name.
  270.       * @return The current state of the feature (true or false)
  271.       * @exception DOMException
  272.       *     NOT_FOUND_ERR: Raised when the DOMBuilder does not recognize
  273.       *     the feature name.
  274.       *
  275.       * @see #setFeature
  276.       * @see #canSetFeature
  277.       */
  278.     bool getFeature(const XMLCh* const name) const;
  279.     /**
  280.       * <p><b>"Experimental - subject to change"</b></p>
  281.       *
  282.       * Query whether setting a feature to a specific value is supported.
  283.       *
  284.       * @param name  The feature name.
  285.       * @param state The requested state of the feature (true or false).
  286.       * @return <code>true</code> if the feature could be successfully set
  287.       *     to the specified value, or <code>false</code> if the feature
  288.       *     is not recognized or the requested value is not supported. The
  289.       *     value of the feature itself is not changed.
  290.       *
  291.       * @see #getFeature
  292.       * @see #setFeature
  293.       */
  294.     bool canSetFeature(const XMLCh* const name, const bool state) const;
  295.     //@}
  296.     // -----------------------------------------------------------------------
  297.     //  Parsing methods
  298.     // -----------------------------------------------------------------------
  299.     /** @name Parsing methods */
  300.     //@{
  301.     /**
  302.       * <p><b>"Experimental - subject to change"</b></p>
  303.       *
  304.       * Parse via an input source object
  305.       *
  306.       * This method invokes the parsing process on the XML file specified
  307.       * by the DOMInputSource parameter. This API is borrowed from the
  308.       * SAX Parser interface.
  309.       *
  310.       * @param source A const reference to the DOMInputSource object which
  311.       *               points to the XML file to be parsed.
  312.       * @return If the DOMBuilder is a synchronous DOMBuilder the newly created
  313.       *         and populated Document is returned. If the DOMBuilder is
  314.       *         asynchronous then <code>null</code> is returned since the
  315.       *         document object is not yet parsed when this method returns.
  316.       * @exception SAXException Any SAX exception, possibly
  317.       *            wrapping another exception.
  318.       * @exception XMLException An exception from the parser or client
  319.       *            handler code.
  320.       * @exception DOMException A DOM exception as per DOM spec.
  321.       *
  322.       * @see DOMInputSource#DOMInputSource
  323.       * @see #setEntityResolver
  324.       * @see #setErrorHandler
  325.       */
  326.     DOMDocument* parse(const DOMInputSource& source);
  327.     /**
  328.       * <p><b>"Experimental - subject to change"</b></p>
  329.       *
  330.       * Parse via a file path or URL
  331.       *
  332.       * This method invokes the parsing process on the XML file specified by
  333.       * the Unicode string parameter 'systemId'.
  334.       *
  335.       * @param systemId A const XMLCh pointer to the Unicode string which
  336.       *                 contains the path to the XML file to be parsed.
  337.       * @return If the DOMBuilder is a synchronous DOMBuilder the newly created
  338.       *         and populated Document is returned. If the DOMBuilder is
  339.       *         asynchronous then <code>null</code> is returned since the
  340.       *         document object is not yet parsed when this method returns.
  341.       * @exception SAXException Any SAX exception, possibly
  342.       *            wrapping another exception.
  343.       * @exception XMLException An exception from the parser or client
  344.       *            handler code.
  345.       * @exception DOM_DOMException A DOM exception as per DOM spec.
  346.       *
  347.       * @see #parse(DOMInputSource,...)
  348.       */
  349.     DOMDocument* parseURI(const XMLCh* const systemId);
  350.     /**
  351.       * <p><b>"Experimental - subject to change"</b></p>
  352.       *
  353.       * Parse via a file path or URL (in the local code page)
  354.       *
  355.       * This method invokes the parsing process on the XML file specified by
  356.       * the native char* string parameter 'systemId'.
  357.       *
  358.       * @param systemId A const char pointer to a native string which
  359.       *                 contains the path to the XML file to be parsed.
  360.       * @return If the DOMBuilder is a synchronous DOMBuilder the newly created
  361.       *         and populated Document is returned. If the DOMBuilder is
  362.       *         asynchronous then <code>null</code> is returned since the
  363.       *         document object is not yet parsed when this method returns.
  364.       * @exception SAXException Any SAX exception, possibly
  365.       *            wrapping another exception.
  366.       * @exception XMLException An exception from the parser or client
  367.       *            handler code.
  368.       * @exception DOM_DOMException A DOM exception as per DOM spec.
  369.       *
  370.       * @see #parse(DOMInputSource,...)
  371.       */
  372.     DOMDocument* parseURI(const char* const systemId);
  373.     /**
  374.       * <p><b>"Experimental - subject to change"</b></p>
  375.       *
  376.       * Parse via an input source object
  377.       *
  378.       * This method invokes the parsing process on the XML file specified
  379.       * by the DOMInputSource parameter, and inserts the content into an
  380.       * existing document at the position specified with the contextNode
  381.       * and action arguments. When parsing the input stream the context node
  382.       * is used for resolving unbound namespace prefixes.
  383.       *
  384.       * @param source A const reference to the DOMInputSource object which
  385.       *               points to the XML file to be parsed.
  386.       * @param contextNode The node that is used as the context for the data
  387.       *                    that is being parsed. This node must be a Document
  388.       *                    node, a DocumentFragment node, or a node of a type
  389.       *                    that is allowed as a child of an element, e.g. it
  390.       *                    can not be an attribute node.
  391.       * @param action This parameter describes which action should be taken
  392.       *               between the new set of node being inserted and the
  393.       *               existing children of the context node.
  394.       * @exception DOMException
  395.       *     NOT_SUPPORTED_ERR: Raised when the DOMBuilder doesn't support
  396.       *     this method.
  397.       *     <br>NO_MODIFICATION_ALLOWED_ERR: Raised if the context node is
  398.       *     readonly.
  399.       */
  400.     virtual void parseWithContext
  401.     (
  402.         const   DOMInputSource& source
  403.         ,       DOMNode* const contextNode
  404.         , const short action
  405.     );
  406.     // -----------------------------------------------------------------------
  407.     //  Non-standard Extension
  408.     // -----------------------------------------------------------------------
  409.     /** @name Non-standard Extension */
  410.     //@{
  411.     /**
  412.       * Query the current value of a property in a DOMBuilder.
  413.       *
  414.       * The builder owns the returned pointer.  The memory allocated for
  415.       * the returned pointer will be destroyed when the builder is deleted.
  416.       *
  417.       * To ensure assessiblity of the returned information after the builder
  418.       * is deleted, callers need to copy and store the returned information
  419.       * somewhere else; otherwise you may get unexpected result.  Since the returned
  420.       * pointer is a generic void pointer, see
  421.       * http://xml.apache.org/xerces-c/program-dom.html#DOMBuilderProperties to learn
  422.       * exactly what type of property value each property returns for replication.
  423.       *
  424.       * @param name The unique identifier (URI) of the property being set.
  425.       * @return     The current value of the property.  The pointer spans the same
  426.       *             life-time as the parser.  A null pointer is returned if nothing
  427.       *             was specified externally.
  428.       * @exception DOMException
  429.       *     <br>NOT_FOUND_ERR: Raised when the DOMBuilder does not recognize
  430.       *     the requested property.
  431.       */
  432.     virtual void* getProperty(const XMLCh* const name) const;
  433.     /**
  434.       * Set the value of any property in a DOMBuilder.
  435.       * See http://xml.apache.org/xerces-c/program-dom.html#DOMBuilderProperties for
  436.       * the list of supported properties.
  437.       *
  438.       * It takes a void pointer as the property value.  Application is required to initialize this void
  439.       * pointer to a correct type.  See http://xml.apache.org/xerces-c/program-dom.html#DOMBuilderProperties
  440.       * to learn exactly what type of property value each property expects for processing.
  441.       * Passing a void pointer that was initialized with a wrong type will lead to unexpected result.
  442.       * If the same property is set more than once, the last one takes effect.
  443.       *
  444.       * @param name The unique identifier (URI) of the property being set.
  445.       * @param value The requested value for the property.
  446.       *            See http://xml.apache.org/xerces-c/program-dom.html#DOMBuilderProperties to learn
  447.       *            exactly what type of property value each property expects for processing.
  448.       *            Passing a void pointer that was initialized with a wrong type will lead
  449.       *            to unexpected result.
  450.       * @exception DOMException
  451.       *     <br>NOT_FOUND_ERR: Raised when the DOMBuilder does not recognize
  452.       *     the requested property.
  453.       */
  454.     virtual void setProperty(const XMLCh* const name, void* value);
  455.     /**
  456.      * Called to indicate that this DOMBuilder is no longer in use
  457.      * and that the implementation may relinquish any resources associated with it.
  458.      *
  459.      */
  460.     virtual void              release();
  461.     /** Reset the documents vector pool and release all the associated memory
  462.       * back to the system.
  463.       *
  464.       * When parsing a document using a DOM parser, all memory allocated
  465.       * for a DOM tree is associated to the DOM document.
  466.       *
  467.       * If you do multiple parse using the same DOM parser instance, then
  468.       * multiple DOM documents will be generated and saved in a vector pool.
  469.       * All these documents (and thus all the allocated memory)
  470.       * won't be deleted until the parser instance is destroyed.
  471.       *
  472.       * If you don't need these DOM documents anymore and don't want to
  473.       * destroy the DOM parser instance at this moment, then you can call this method
  474.       * to reset the document vector pool and release all the allocated memory
  475.       * back to the system.
  476.       *
  477.       * It is an error to call this method if you are in the middle of a
  478.       * parse (e.g. in the mid of a progressive parse).
  479.       *
  480.       * @exception IOException An exception from the parser if this function
  481.       *            is called when a parse is in progress.
  482.       *
  483.       */
  484.     virtual void resetDocumentPool();
  485.     /**
  486.       * Preparse schema grammar (XML Schema, DTD, etc.) via an input source
  487.       * object.
  488.       *
  489.       * This method invokes the preparsing process on a schema grammar XML
  490.       * file specified by the DOMInputSource parameter. If the 'toCache' flag
  491.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  492.       * key is found in the pool, no caching of any grammar will take place.
  493.       *
  494.       * <p><b>"Experimental - subject to change"</b></p>
  495.       *
  496.       * @param source A const reference to the DOMInputSource object which
  497.       *               points to the schema grammar file to be preparsed.
  498.       * @param grammarType The grammar type (Schema or DTD).
  499.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  500.       *                otherwise, no chaching. Default is <code>false</code>.
  501.       * @return The preparsed schema grammar object (SchemaGrammar or
  502.       *         DTDGrammar). That grammar object is owned by the parser.
  503.       *
  504.       * @exception SAXException Any SAX exception, possibly
  505.       *            wrapping another exception.
  506.       * @exception XMLException An exception from the parser or client
  507.       *            handler code.
  508.       * @exception DOMException A DOM exception as per DOM spec.
  509.       *
  510.       * @see DOMInputSource#DOMInputSource
  511.       */
  512.     virtual Grammar* loadGrammar(const DOMInputSource& source,
  513.                              const short grammarType,
  514.                              const bool toCache = false);
  515.     /**
  516.       * Preparse schema grammar (XML Schema, DTD, etc.) via a file path or URL
  517.       *
  518.       * This method invokes the preparsing process on a schema grammar XML
  519.       * file specified by the file path parameter. If the 'toCache' flag
  520.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  521.       * key is found in the pool, no caching of any grammar will take place.
  522.       *
  523.       * <p><b>"Experimental - subject to change"</b></p>
  524.       *
  525.       * @param systemId A const XMLCh pointer to the Unicode string which
  526.       *                 contains the path to the XML grammar file to be
  527.       *                 preparsed.
  528.       * @param grammarType The grammar type (Schema or DTD).
  529.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  530.       *                otherwise, no chaching. Default is <code>false</code>.
  531.       * @return The preparsed schema grammar object (SchemaGrammar or
  532.       *         DTDGrammar). That grammar object is owned by the parser.
  533.       *
  534.       * @exception SAXException Any SAX exception, possibly
  535.       *            wrapping another exception.
  536.       * @exception XMLException An exception from the parser or client
  537.       *            handler code.
  538.       * @exception DOMException A DOM exception as per DOM spec.
  539.       */
  540.     virtual Grammar* loadGrammar(const XMLCh* const systemId,
  541.                              const short grammarType,
  542.                              const bool toCache = false);
  543.     /**
  544.       * Preparse schema grammar (XML Schema, DTD, etc.) via a file path or URL
  545.       *
  546.       * This method invokes the preparsing process on a schema grammar XML
  547.       * file specified by the file path parameter. If the 'toCache' flag
  548.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  549.       * key is found in the pool, no caching of any grammar will take place.
  550.       *
  551.       * <p><b>"Experimental - subject to change"</b></p>
  552.       *
  553.       * @param systemId A const char pointer to a native string which contains
  554.       *                 the path to the XML grammar file to be preparsed.
  555.       * @param grammarType The grammar type (Schema or DTD).
  556.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  557.       *                otherwise, no chaching. Default is <code>false</code>.
  558.       * @return The preparsed schema grammar object (SchemaGrammar or
  559.       *         DTDGrammar). That grammar object is owned by the parser.
  560.       *
  561.       * @exception SAXException Any SAX exception, possibly
  562.       *            wrapping another exception.
  563.       * @exception XMLException An exception from the parser or client
  564.       *            handler code.
  565.       * @exception DOMException A DOM exception as per DOM spec.
  566.       */
  567.     virtual Grammar* loadGrammar(const char* const systemId,
  568.                                  const short grammarType,
  569.                                  const bool toCache = false);
  570.     /**
  571.      * Retrieve the grammar that is associated with the specified namespace key
  572.      *
  573.      * @param  nameSpaceKey Namespace key
  574.      * @return Grammar associated with the Namespace key.
  575.      */
  576.     virtual Grammar* getGrammar(const XMLCh* const nameSpaceKey) const;
  577.     /**
  578.      * Retrieve the grammar where the root element is declared.
  579.      *
  580.      * @return Grammar where root element declared
  581.      */
  582.     virtual Grammar* getRootGrammar() const;
  583.     /**
  584.      * Returns the string corresponding to a URI id from the URI string pool.
  585.      *
  586.      * @param uriId id of the string in the URI string pool.
  587.      * @return URI string corresponding to the URI id.
  588.      */
  589.     virtual const XMLCh* getURIText(unsigned int uriId) const;
  590.     /**
  591.       * Clear the cached grammar pool
  592.       */
  593.     virtual void resetCachedGrammarPool();
  594.     /**
  595.       * Returns the current src offset within the input source.
  596.       *
  597.       * @return offset within the input source
  598.       */
  599.     virtual unsigned int getSrcOffset() const;
  600.     //@}
  601.     // -----------------------------------------------------------------------
  602.     //  Implementation of the XMLErrorReporter interface.
  603.     // -----------------------------------------------------------------------
  604.     /** @name Implementation of the XMLErrorReporter interface. */
  605.     //@{
  606.     /** Handle errors reported from the parser
  607.       *
  608.       * This method is used to report back errors found while parsing the
  609.       * XML file. This method is also borrowed from the SAX specification.
  610.       * It calls the corresponding user installed Error Handler method:
  611.       * 'fatal', 'error', 'warning' depending on the severity of the error.
  612.       * This classification is defined by the XML specification.
  613.       *
  614.       * @param errCode An integer code for the error.
  615.       * @param msgDomain A const pointer to an Unicode string representing
  616.       *                  the message domain to use.
  617.       * @param errType An enumeration classifying the severity of the error.
  618.       * @param errorText A const pointer to an Unicode string representing
  619.       *                  the text of the error message.
  620.       * @param systemId  A const pointer to an Unicode string representing
  621.       *                  the system id of the XML file where this error
  622.       *                  was discovered.
  623.       * @param publicId  A const pointer to an Unicode string representing
  624.       *                  the public id of the XML file where this error
  625.       *                  was discovered.
  626.       * @param lineNum   The line number where the error occurred.
  627.       * @param colNum    The column number where the error occurred.
  628.       * @see DOMErrorHandler
  629.       */
  630.     virtual void error
  631.     (
  632.         const   unsigned int                errCode
  633.         , const XMLCh* const                msgDomain
  634.         , const XMLErrorReporter::ErrTypes  errType
  635.         , const XMLCh* const                errorText
  636.         , const XMLCh* const                systemId
  637.         , const XMLCh* const                publicId
  638.         , const XMLSSize_t                  lineNum
  639.         , const XMLSSize_t                  colNum
  640.     );
  641.     /** Reset any error data before a new parse
  642.      *
  643.       * This method allows the user installed Error Handler callback to
  644.       * 'reset' itself.
  645.       *
  646.       * <b><font color="#FF0000">This method is a no-op for this DOM
  647.       * implementation.</font></b>
  648.       */
  649.     virtual void resetErrors();
  650.     //@}
  651.     // -----------------------------------------------------------------------
  652.     //  Implementation of the XMLEntityHandler interface.
  653.     // -----------------------------------------------------------------------
  654.     /** @name Implementation of the XMLEntityHandler interface. */
  655.     //@{
  656.     /** Handle an end of input source event
  657.       *
  658.       * This method is used to indicate the end of parsing of an external
  659.       * entity file.
  660.       *
  661.       * <b><font color="#FF0000">This method is a no-op for this DOM
  662.       * implementation.</font></b>
  663.       *
  664.       * @param inputSource A const reference to the InputSource object
  665.       *                    which points to the XML file being parsed.
  666.       * @see InputSource
  667.       */
  668.     virtual void endInputSource(const InputSource& inputSource);
  669.     /** Expand a system id
  670.       *
  671.       * This method allows an installed XMLEntityHandler to further
  672.       * process any system id's of enternal entities encountered in
  673.       * the XML file being parsed, such as redirection etc.
  674.       *
  675.       * <b><font color="#FF0000">This method always returns 'false'
  676.       * for this DOM implementation.</font></b>
  677.       *
  678.       * @param systemId  A const pointer to an Unicode string representing
  679.       *                  the system id scanned by the parser.
  680.       * @param toFill    A pointer to a buffer in which the application
  681.       *                  processed system id is stored.
  682.       * @return 'true', if any processing is done, 'false' otherwise.
  683.       */
  684.     virtual bool expandSystemId
  685.     (
  686.         const   XMLCh* const    systemId
  687.         ,       XMLBuffer&      toFill
  688.     );
  689.     /** Reset any entity handler information
  690.       *
  691.       * This method allows the installed XMLEntityHandler to reset
  692.       * itself.
  693.       *
  694.       * <b><font color="#FF0000">This method is a no-op for this DOM
  695.       * implementation.</font></b>
  696.       */
  697.     virtual void resetEntities();
  698.     /** Resolve a public/system id
  699.       *
  700.       * This method allows a user installed entity handler to further
  701.       * process any pointers to external entities. The applications can
  702.       * implement 'redirection' via this callback. This method is also
  703.       * borrowed from the SAX specification.
  704.       *
  705.       * @param publicId A const pointer to a Unicode string representing the
  706.       *                 public id of the entity just parsed.
  707.       * @param systemId A const pointer to a Unicode string representing the
  708.       *                 system id of the entity just parsed.
  709.       * @param baseURI  A const pointer to a Unicode string representing the
  710.       *                 base URI of the entity just parsed,
  711.       *                 or <code>null</code> if there is no base URI.
  712.       * @return The value returned by the user installed resolveEntity
  713.       *         method or NULL otherwise to indicate no processing was done.
  714.       *         The returned InputSource is owned by the DOMBuilder which is
  715.       *         responsible to clean up the memory.
  716.       * @see DOMEntityResolver
  717.       * @see XMLEntityHandler
  718.       */
  719.     virtual InputSource* resolveEntity
  720.     (
  721.         const   XMLCh* const    publicId
  722.         , const XMLCh* const    systemId
  723.         , const XMLCh* const    baseURI = 0
  724.     );
  725.     /** Handle a 'start input source' event
  726.       *
  727.       * This method is used to indicate the start of parsing an external
  728.       * entity file.
  729.       *
  730.       * <b><font color="#FF0000">This method is a no-op for this DOM parse
  731.       * implementation.</font></b>
  732.       *
  733.       * @param inputSource A const reference to the InputSource object
  734.       *                    which points to the external entity
  735.       *                    being parsed.
  736.       */
  737.     virtual void startInputSource(const InputSource& inputSource);
  738.     //@}
  739. private :
  740.     // -----------------------------------------------------------------------
  741.     //  Private data members
  742.     //
  743.     //  fEntityResolver
  744.     //      The installed DOM entity resolver, if any. Null if none.
  745.     //
  746.     //  fErrorHandler
  747.     //      The installed DOM error handler, if any. Null if none.
  748.     //
  749.     //  fFilter
  750.     //      The installed application filter, if any. Null if none.
  751.     //
  752.     //  fCharsetOverridesXMLEncoding
  753.     //      Indicates if the "charset-overrides-xml-encoding" is set or not
  754.     //
  755.     //  fUserAdoptsDocument
  756.     //      The DOMDocument ownership has been transferred to application
  757.     //      If set to true, the parser does not own the document anymore
  758.     //      and thus will not release its memory.
  759.     //-----------------------------------------------------------------------
  760.     bool                        fAutoValidation;
  761.     bool                        fValidation;
  762.     DOMEntityResolver*          fEntityResolver;
  763.     DOMErrorHandler*            fErrorHandler;
  764.     DOMBuilderFilter*           fFilter;
  765.     bool                        fCharsetOverridesXMLEncoding;
  766.     bool                        fUserAdoptsDocument;
  767. };
  768. // ---------------------------------------------------------------------------
  769. //  DOMBuilderImpl: Handlers for the XMLEntityHandler interface
  770. // ---------------------------------------------------------------------------
  771. inline void DOMBuilderImpl::endInputSource(const InputSource&)
  772. {
  773.     // The DOM entity resolver doesn't handle this
  774. }
  775. inline bool DOMBuilderImpl::expandSystemId(const XMLCh* const, XMLBuffer&)
  776. {
  777.     // The DOM entity resolver doesn't handle this
  778.     return false;
  779. }
  780. inline void DOMBuilderImpl::resetEntities()
  781. {
  782.     // Nothing to do on this one
  783. }
  784. inline void DOMBuilderImpl::startInputSource(const InputSource&)
  785. {
  786.     // The DOM entity resolver doesn't handle this
  787. }
  788. // ---------------------------------------------------------------------------
  789. //  DOMBuilderImpl: Getter methods
  790. // ---------------------------------------------------------------------------
  791. inline DOMErrorHandler* DOMBuilderImpl::getErrorHandler()
  792. {
  793.     return fErrorHandler;
  794. }
  795. inline const DOMErrorHandler* DOMBuilderImpl::getErrorHandler() const
  796. {
  797.     return fErrorHandler;
  798. }
  799. inline DOMEntityResolver* DOMBuilderImpl::getEntityResolver()
  800. {
  801.     return fEntityResolver;
  802. }
  803. inline const DOMEntityResolver* DOMBuilderImpl::getEntityResolver() const
  804. {
  805.     return fEntityResolver;
  806. }
  807. inline DOMBuilderFilter* DOMBuilderImpl::getFilter()
  808. {
  809.     return fFilter;
  810. }
  811. inline const DOMBuilderFilter* DOMBuilderImpl::getFilter() const
  812. {
  813.     return fFilter;
  814. }
  815. XERCES_CPP_NAMESPACE_END
  816. #endif