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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2002, 2003 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: AbstractDOMParser.hpp,v 1.19 2003/05/16 21:36:59 knoaman Exp $
  58.  *
  59.  */
  60. #if !defined(ABSTRACTDOMPARSER_HPP)
  61. #define ABSTRACTDOMPARSER_HPP
  62. #include <xercesc/dom/DOMDocument.hpp>
  63. #include <xercesc/framework/XMLDocumentHandler.hpp>
  64. #include <xercesc/framework/XMLErrorReporter.hpp>
  65. #include <xercesc/framework/XMLEntityHandler.hpp>
  66. #include <xercesc/util/SecurityManager.hpp>
  67. #include <xercesc/util/ValueStackOf.hpp>
  68. #include <xercesc/validators/DTD/DocTypeHandler.hpp>
  69. #include <xercesc/dom/DOMDocumentType.hpp>
  70. #include <xercesc/validators/DTD/DTDElementDecl.hpp>
  71. #include <xercesc/framework/XMLBufferMgr.hpp>
  72. XERCES_CPP_NAMESPACE_BEGIN
  73. class XMLPScanToken;
  74. class XMLScanner;
  75. class XMLValidator;
  76. class DOMDocumentImpl;
  77. class DOMDocumentTypeImpl;
  78. class DOMElement;
  79. class GrammarResolver;
  80. /**
  81.   * This class implements the Document Object Model (DOM) interface.
  82.   * It is used as a base for DOM parsers (i.e. XercesDOMParser, DOMBuilder).
  83.   */
  84. class PARSERS_EXPORT AbstractDOMParser :
  85.     public XMemory
  86.     , public XMLDocumentHandler
  87.     , public XMLErrorReporter
  88.     , public XMLEntityHandler
  89.     , public DocTypeHandler
  90. {
  91. public :
  92.     // -----------------------------------------------------------------------
  93.     //  Class types
  94.     // -----------------------------------------------------------------------
  95.     /** @name Public constants */
  96.     //@{
  97.     /** ValScheme enum used in setValidationScheme
  98.       *    Val_Never:  Do not report validation errors.
  99.       *    Val_Always: The parser will always report validation errors.
  100.       *    Val_Auto:   The parser will report validation errors only if a grammar is specified.
  101.       *
  102.       * @see #setValidationScheme
  103.       */
  104.     enum ValSchemes
  105.     {
  106.         Val_Never
  107.         , Val_Always
  108.         , Val_Auto
  109.     };
  110.     //@}
  111.     // -----------------------------------------------------------------------
  112.     //  Constructors and Detructor
  113.     // -----------------------------------------------------------------------
  114.     /** @name Destructor */
  115.     //@{
  116.     /**
  117.       * Destructor
  118.       */
  119.     virtual ~AbstractDOMParser();
  120.     //@}
  121.     // -----------------------------------------------------------------------
  122.     //  Utility methods
  123.     // -----------------------------------------------------------------------
  124.     /** @name Utility methods */
  125.     //@{
  126.     /** Reset the parser
  127.       *
  128.       * This method resets the state of the DOM driver and makes
  129.       * it ready for a fresh parse run.
  130.       */
  131.     void reset();
  132.     /** Adopt the DOM document
  133.       *
  134.       * This method returns the DOMDocument object representing the
  135.       * root of the document tree.
  136.       *
  137.       * The caller will adopt the DOMDocument and thus is responsible to
  138.       * call DOMDocument::release() to release the associated memory.
  139.       * The parser will not delete it.   The ownership is transferred
  140.       * from the parser to the caller.
  141.       *
  142.       * @return The adopted DOMDocument object which represents the entire
  143.       *         XML document.
  144.       */
  145.     DOMDocument* adoptDocument();
  146.     //@}
  147.     // -----------------------------------------------------------------------
  148.     //  Getter methods
  149.     // -----------------------------------------------------------------------
  150.     /** @name Getter methods */
  151.     //@{
  152.     /** Get the DOM document
  153.       *
  154.       * This method returns the DOMDocument object representing the
  155.       * root of the document tree. This object provides the primary
  156.       * access to the document's data.
  157.       *
  158.       * The returned DOMDocument object is owned by the parser.
  159.       *
  160.       * @return The DOMDocument object which represents the entire
  161.       *         XML document.
  162.       */
  163.     DOMDocument* getDocument();
  164.     /** Get a const reference to the validator
  165.       *
  166.       * This method returns a reference to the parser's installed
  167.       * validator.
  168.       *
  169.       * @return A const reference to the installed validator object.
  170.       */
  171.     const XMLValidator& getValidator() const;
  172.     /**
  173.       * This method returns an enumerated value that indicates the current
  174.       * validation scheme set on this parser.
  175.       *
  176.       * @return The ValSchemes value current set on this parser.
  177.       * @see #setValidationScheme
  178.       */
  179.     ValSchemes getValidationScheme() const;
  180.     /** Get the 'do schema' flag
  181.       *
  182.       * This method returns the state of the parser's schema processing
  183.       * flag.
  184.       *
  185.       * @return true, if the parser is currently configured to
  186.       *         understand schema, false otherwise.
  187.       *
  188.       * @see #setDoSchema
  189.       */
  190.     bool getDoSchema() const;
  191.     /** Get the 'full schema constraint checking' flag
  192.       *
  193.       * This method returns the state of the parser's full schema constraint
  194.       * checking flag.
  195.       *
  196.       * @return true, if the parser is currently configured to
  197.       *         have full schema constraint checking, false otherwise.
  198.       *
  199.       * @see #setValidationSchemaFullChecking
  200.       */
  201.     bool getValidationSchemaFullChecking() const;
  202.     /** Get error count from the last parse operation.
  203.       *
  204.       * This method returns the error count from the last parse
  205.       * operation. Note that this count is actually stored in the
  206.       * scanner, so this method simply returns what the
  207.       * scanner reports.
  208.       *
  209.       * @return number of errors encountered during the latest
  210.       * parse operation.
  211.       *
  212.       */
  213.     int getErrorCount() const;
  214.     /** Get the 'do namespaces' flag
  215.       *
  216.       * This method returns the state of the parser's namespace processing
  217.       * flag.
  218.       *
  219.       * @return true, if the parser is currently configured to
  220.       *         understand namespaces, false otherwise.
  221.       *
  222.       * @see #setDoNamespaces
  223.       */
  224.     bool getDoNamespaces() const;
  225.     /** Get the 'exit on first error' flag
  226.       *
  227.       * This method returns the state of the parser's
  228.       * exit-on-First-Fatal-Error flag. If this flag is true, then the
  229.       * parse will exit the first time it sees any non-wellformed XML or
  230.       * any validity error. The default state is true.
  231.       *
  232.       * @return true, if the parser is currently configured to
  233.       *         exit on the first fatal error, false otherwise.
  234.       *
  235.       * @see #setExitOnFirstFatalError
  236.       */
  237.     bool getExitOnFirstFatalError() const;
  238.     /**
  239.       * This method returns the state of the parser's
  240.       * validation-constraint-fatal flag.
  241.       *
  242.       * @return true, if the parser is currently configured to
  243.       *         set validation constraint errors as fatal, false
  244.       *         otherwise.
  245.       *
  246.       * @see #setValidationContraintFatal
  247.       */
  248.     bool getValidationConstraintFatal() const;
  249.     /** Get the 'include entity references' flag
  250.       *
  251.       * This method returns the flag that specifies whether the parser is
  252.       * creating entity reference nodes in the DOM tree being produced.
  253.       *
  254.       * @return  The state of the create entity reference node
  255.       *               flag.
  256.       * @see #setCreateEntityReferenceNodes
  257.       */
  258.     bool  getCreateEntityReferenceNodes()const;
  259.    /** Get the 'include ignorable whitespace' flag.
  260.       *
  261.       * This method returns the state of the parser's include ignorable
  262.       * whitespace flag.
  263.       *
  264.       * @return 'true' if the include ignorable whitespace flag is set on
  265.       *         the parser, 'false' otherwise.
  266.       *
  267.       * @see #setIncludeIgnorableWhitespace
  268.       */
  269.     bool getIncludeIgnorableWhitespace() const;
  270.    /** Get the set of Namespace/SchemaLocation that is specified externaly.
  271.       *
  272.       * This method returns the list of Namespace/SchemaLocation that was
  273.       * specified using setExternalSchemaLocation.
  274.       *
  275.       * The parser owns the returned string, and the memory allocated for
  276.       * the returned string will be destroyed when the parser is deleted.
  277.       *
  278.       * To ensure assessiblity of the returned information after the parser
  279.       * is deleted, callers need to copy and store the returned information
  280.       * somewhere else.
  281.       *
  282.       * @return a pointer to the list of Namespace/SchemaLocation that was
  283.       *         specified externally.  The pointer spans the same life-time as
  284.       *         the parser.  A null pointer is returned if nothing
  285.       *         was specified externally.
  286.       *
  287.       * @see #setExternalSchemaLocation(const XMLCh* const)
  288.       */
  289.     XMLCh* getExternalSchemaLocation() const;
  290.    /** Get the noNamespace SchemaLocation that is specified externaly.
  291.       *
  292.       * This method returns the no target namespace XML Schema Location
  293.       * that was specified using setExternalNoNamespaceSchemaLocation.
  294.       *
  295.       * The parser owns the returned string, and the memory allocated for
  296.       * the returned string will be destroyed when the parser is deleted.
  297.       *
  298.       * To ensure assessiblity of the returned information after the parser
  299.       * is deleted, callers need to copy and store the returned information
  300.       * somewhere else.
  301.       *
  302.       * @return a pointer to the no target namespace Schema Location that was
  303.       *         specified externally.  The pointer spans the same life-time as
  304.       *         the parser.  A null pointer is returned if nothing
  305.       *         was specified externally.
  306.       *
  307.       * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
  308.       */
  309.     XMLCh* getExternalNoNamespaceSchemaLocation() const;
  310.    /** Get the SecurityManager instance attached to this parser.
  311.       *
  312.       * This method returns the security manager 
  313.       * that was specified using setSecurityManager.
  314.       *
  315.       * The SecurityManager instance must have been specified by the application; 
  316.       * this should not be deleted until after the parser has been deleted (or
  317.       * a new SecurityManager instance has been supplied to the parser).
  318.       * 
  319.       * @return a pointer to the SecurityManager instance 
  320.       *         specified externally.  A null pointer is returned if nothing
  321.       *         was specified externally.
  322.       *
  323.       * @see #setSecurityManager(const SecurityManager* const)
  324.       */
  325.     SecurityManager* getSecurityManager() const;
  326.     /** Get the 'Loading External DTD' flag
  327.       *
  328.       * This method returns the state of the parser's loading external DTD
  329.       * flag.
  330.       *
  331.       * @return false, if the parser is currently configured to
  332.       *         ignore external DTD completely, true otherwise.
  333.       *
  334.       * @see #setLoadExternalDTD
  335.       * @see #getValidationScheme
  336.       */
  337.     bool getLoadExternalDTD() const;
  338.     /** Get the 'create comment node' flag
  339.       *
  340.       * This method returns the flag that specifies whether the parser is
  341.       * creating comment nodes in the DOM tree being produced.
  342.       *
  343.       * @return  The state of the create comment node flag.
  344.       * @see #setCreateCommentNodes
  345.       */
  346.     bool  getCreateCommentNodes()const;
  347.     /**
  348.       * Get the 'calculate src offset flag'
  349.       *
  350.       * This method returns the state of the parser's src offset calculation
  351.       * when parsing an XML document.
  352.       *
  353.       * @return true, if the parser is currently configured to
  354.       *         calculate src offsets, false otherwise.
  355.       *
  356.       * @see #setCalculateSrcOfs
  357.       */
  358.     bool getCalculateSrcOfs() const;
  359.     /**
  360.       * Get the 'force standard uri flag'
  361.       *
  362.       * This method returns the state if the parser forces standard uri
  363.       *
  364.       * @return true, if the parser is currently configured to
  365.       *         force standard uri, i.e. malformed uri will be rejected.
  366.       *
  367.       * @see #setStandardUriConformant
  368.       */
  369.     bool getStandardUriConformant() const;
  370.     //@}
  371.     // -----------------------------------------------------------------------
  372.     //  Setter methods
  373.     // -----------------------------------------------------------------------
  374.     /** @name Setter methods */
  375.     //@{
  376.     /** Set the 'do namespaces' flag
  377.       *
  378.       * This method allows users to enable or disable the parser's
  379.       * namespace processing. When set to true, parser starts enforcing
  380.       * all the constraints and rules specified by the NameSpace
  381.       * specification.
  382.       *
  383.       * The parser's default state is: false.
  384.       *
  385.       * @param newState The value specifying whether NameSpace rules should
  386.       *                 be enforced or not.
  387.       *
  388.       * @see #getDoNamespaces
  389.       */
  390.     void setDoNamespaces(const bool newState);
  391.     /** Set the 'exit on first error' flag
  392.       *
  393.       * This method allows users to set the parser's behaviour when it
  394.       * encounters the first fatal error. If set to true, the parser
  395.       * will exit at the first fatal error. If false, then it will
  396.       * report the error and continue processing.
  397.       *
  398.       * The default value is 'true' and the parser exits on the
  399.       * first fatal error.
  400.       *
  401.       * @param newState The value specifying whether the parser should
  402.       *                 continue or exit when it encounters the first
  403.       *                 fatal error.
  404.       *
  405.       * @see #getExitOnFirstFatalError
  406.       */
  407.     void setExitOnFirstFatalError(const bool newState);
  408.     /**
  409.       * This method allows users to set the parser's behaviour when it
  410.       * encounters a validtion constraint error. If set to true, and the
  411.       * the parser will treat validation error as fatal and will exit depends on the
  412.       * state of "getExitOnFirstFatalError". If false, then it will
  413.       * report the error and continue processing.
  414.       *
  415.       * Note: setting this true does not mean the validation error will be printed with
  416.       * the word "Fatal Error".   It is still printed as "Error", but the parser
  417.       * will exit if "setExitOnFirstFatalError" is set to true.
  418.       *
  419.       * <p>The default value is 'false'.</p>
  420.       *
  421.       * @param newState If true, the parser will exit if "setExitOnFirstFatalError"
  422.       *                 is set to true.
  423.       *
  424.       * @see #getValidationConstraintFatal
  425.       * @see #setExitOnFirstFatalError
  426.       */
  427.     void setValidationConstraintFatal(const bool newState);
  428.      /** Set the 'include entity references' flag
  429.       *
  430.       * This method allows the user to specify whether the parser should
  431.       * create entity reference nodes in the DOM tree being produced.
  432.       * When the 'create' flag is
  433.       * true, the parser will create EntityReference nodes in the DOM tree.
  434.       * The EntityReference nodes and their child nodes will be read-only.
  435.       * When the 'create' flag is false, no EntityReference nodes will be created.
  436.       * <p>The replacement text
  437.       * of the entity is included in either case, either as a
  438.       * child of the Entity Reference node or in place at the location
  439.       * of the reference.
  440.       * <p>The default value is 'true'.
  441.       *
  442.       * @param create The new state of the create entity reference nodes
  443.       *               flag.
  444.       * @see #getCreateEntityReferenceNodes
  445.       */
  446.     void setCreateEntityReferenceNodes(const bool create);
  447.    /** Set the 'include ignorable whitespace' flag
  448.       *
  449.       * This method allows the user to specify whether a validating parser
  450.       * should include ignorable whitespaces as text nodes.  It has no effect
  451.       * on non-validating parsers which always include non-markup text.
  452.       * <p>When set to true (also the default), ignorable whitespaces will be
  453.       * added to the DOM tree as text nodes.  The method
  454.       * DOMText::isIgnorableWhitespace() will return true for those text
  455.       * nodes only.
  456.       * <p>When set to false, all ignorable whitespace will be discarded and
  457.       * no text node is added to the DOM tree.  Note: applications intended
  458.       * to process the "xml:space" attribute should not set this flag to false.
  459.       * And this flag also overrides any schema datateye whitespace facets,
  460.       * that is, all ignorable whitespace will be discarded even though
  461.       * 'preserve' is set in schema datatype whitespace facets.
  462.       *
  463.       * @param include The new state of the include ignorable whitespace
  464.       *                flag.
  465.       *
  466.       * @see #getIncludeIgnorableWhitespace
  467.       */
  468.     void setIncludeIgnorableWhitespace(const bool include);
  469.     /**
  470.       * This method allows users to set the validation scheme to be used
  471.       * by this parser. The value is one of the ValSchemes enumerated values
  472.       * defined by this class:
  473.       *
  474.       * <br>  Val_Never  - turn off validation
  475.       * <br>  Val_Always - turn on validation
  476.       * <br>  Val_Auto   - turn on validation if any internal/external
  477.       *                  DTD subset have been seen
  478.       *
  479.       * <p>The parser's default state is: Val_Auto.</p>
  480.       *
  481.       * @param newScheme The new validation scheme to use.
  482.       *
  483.       * @see #getValidationScheme
  484.       */
  485.     void setValidationScheme(const ValSchemes newScheme);
  486.     /** Set the 'do schema' flag
  487.       *
  488.       * This method allows users to enable or disable the parser's
  489.       * schema processing. When set to false, parser will not process
  490.       * any schema found.
  491.       *
  492.       * The parser's default state is: false.
  493.       *
  494.       * Note: If set to true, namespace processing must also be turned on.
  495.       *
  496.       * @param newState The value specifying whether schema support should
  497.       *                 be enforced or not.
  498.       *
  499.       * @see #getDoSchema
  500.       */
  501.     void setDoSchema(const bool newState);
  502.     /**
  503.       * This method allows the user to turn full Schema constraint checking on/off.
  504.       * Only takes effect if Schema validation is enabled.
  505.       * If turned off, partial constraint checking is done.
  506.       *
  507.       * Full schema constraint checking includes those checking that may
  508.       * be time-consuming or memory intensive. Currently, particle unique
  509.       * attribution constraint checking and particle derivation resriction checking
  510.       * are controlled by this option.
  511.       *
  512.       * The parser's default state is: false.
  513.       *
  514.       * @param schemaFullChecking True to turn on full schema constraint checking.
  515.       *
  516.       * @see #getValidationSchemaFullChecking
  517.       */
  518.     void setValidationSchemaFullChecking(const bool schemaFullChecking);
  519.     /**
  520.       * This method allows the user to specify a list of schemas to use.
  521.       * If the targetNamespace of a schema specified using this method matches
  522.       * the targetNamespace of a schema occuring in the instance document in
  523.       * the schemaLocation attribute, or if the targetNamespace matches the
  524.       * namespace attribute of the "import" element, the schema specified by the
  525.       * user using this method will be used (i.e., the schemaLocation attribute
  526.       * in the instance document or on the "import" element will be effectively ignored).
  527.       *
  528.       * If this method is called more than once, only the last one takes effect.
  529.       *
  530.       * The syntax is the same as for schemaLocation attributes in instance
  531.       * documents: e.g, "http://www.example.com file_name.xsd". The user can
  532.       * specify more than one XML Schema in the list.
  533.       *
  534.       * @param schemaLocation the list of schemas to use
  535.       *
  536.       * @see #getExternalSchemaLocation
  537.       */
  538.     void setExternalSchemaLocation(const XMLCh* const schemaLocation);
  539.     /**
  540.       * This method is same as setExternalSchemaLocation(const XMLCh* const).
  541.       * It takes native char string as parameter
  542.       *
  543.       * @param schemaLocation the list of schemas to use
  544.       *
  545.       * @see #setExternalSchemaLocation(const XMLCh* const)
  546.       */
  547.     void setExternalSchemaLocation(const char* const schemaLocation);
  548.     /**
  549.       * This method allows the user to specify the no target namespace XML
  550.       * Schema Location externally.  If specified, the instance document's
  551.       * noNamespaceSchemaLocation attribute will be effectively ignored.
  552.       *
  553.       * If this method is called more than once, only the last one takes effect.
  554.       *
  555.       * The syntax is the same as for the noNamespaceSchemaLocation attribute
  556.       * that may occur in an instance document: e.g."file_name.xsd".
  557.       *
  558.       * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
  559.       *
  560.       * @see #getExternalNoNamespaceSchemaLocation
  561.       */
  562.     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
  563.     /**
  564.       * This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const).
  565.       * It takes native char string as parameter
  566.       *
  567.       * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
  568.       *
  569.       * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
  570.       */
  571.     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
  572.     /**
  573.       * This allows an application to set a SecurityManager on
  574.       * the parser; this object stores information that various
  575.       * components use to limit their consumption of system
  576.       * resources while processing documents.
  577.       *
  578.       * If this method is called more than once, only the last one takes effect.
  579.       * It may not be reset during a parse.
  580.       *
  581.       *
  582.       * @param securityManager  the SecurityManager instance to
  583.       * be used by this parser
  584.       *
  585.       * @see #getSecurityManager
  586.       */
  587.     void setSecurityManager(SecurityManager* const securityManager);
  588.     /** Set the 'Loading External DTD' flag
  589.       *
  590.       * This method allows users to enable or disable the loading of external DTD.
  591.       * When set to false, the parser will ignore any external DTD completely
  592.       * if the validationScheme is set to Val_Never.
  593.       *
  594.       * The parser's default state is: true.
  595.       *
  596.       * This flag is ignored if the validationScheme is set to Val_Always or Val_Auto.
  597.       *
  598.       * @param newState The value specifying whether external DTD should
  599.       *                 be loaded or not.
  600.       *
  601.       * @see #getLoadExternalDTD
  602.       * @see #setValidationScheme
  603.       */
  604.     void setLoadExternalDTD(const bool newState);
  605.      /** Set the 'create comment nodes' flag
  606.       *
  607.       * This method allows the user to specify whether the parser should
  608.       * create comment nodes in the DOM tree being produced.
  609.       * <p>The default value is 'true'.
  610.       *
  611.       * @param create The new state of the create comment nodes
  612.       *               flag.
  613.       * @see #getCreateCommentNodes
  614.       */
  615.     void setCreateCommentNodes(const bool create);
  616.     /** Enable/disable src offset calculation
  617.       *
  618.       * This method allows users to enable/disable src offset calculation.
  619.       * Disabling the calculation will improve performance.
  620.       *
  621.       * The parser's default state is: false.
  622.       *
  623.       * @param newState The value specifying whether we should enable or
  624.       *                 disable src offset calculation
  625.       *
  626.       * @see #getCalculateSrcOfs
  627.       */
  628.     void setCalculateSrcOfs(const bool newState);
  629.     /** Force standard uri
  630.       *
  631.       * This method allows users to tell the parser to force standard uri conformance.
  632.       *
  633.       * The parser's default state is: false.
  634.       *
  635.       * @param newState The value specifying whether the parser should reject malformed URI.
  636.       *
  637.       * @see #getStandardUriConformant
  638.       */
  639.     void setStandardUriConformant(const bool newState);
  640.     /** Set the scanner to use when scanning the XML document
  641.       *
  642.       * This method allows users to set the the scanner to use
  643.       * when scanning a given XML document.
  644.       *
  645.       * @param scannerName The name of the desired scanner
  646.       */
  647.     void useScanner(const XMLCh* const scannerName);
  648.     //@}
  649.     // -----------------------------------------------------------------------
  650.     //  Parsing methods
  651.     // -----------------------------------------------------------------------
  652.     /** @name Parsing methods */
  653.     //@{
  654.     /** Parse via an input source object
  655.       *
  656.       * This method invokes the parsing process on the XML file specified
  657.       * by the InputSource parameter. This API is borrowed from the
  658.       * SAX Parser interface.
  659.       *
  660.       * @param source A const reference to the InputSource object which
  661.       *               points to the XML file to be parsed.
  662.       * @exception SAXException Any SAX exception, possibly
  663.       *            wrapping another exception.
  664.       * @exception XMLException An exception from the parser or client
  665.       *            handler code.
  666.       * @exception DOMException A DOM exception as per DOM spec.
  667.       * @see InputSource#InputSource
  668.       */
  669.     void parse(const InputSource& source);
  670.     /** Parse via a file path or URL
  671.       *
  672.       * This method invokes the parsing process on the XML file specified by
  673.       * the Unicode string parameter 'systemId'. This method is borrowed
  674.       * from the SAX Parser interface.
  675.       *
  676.       * @param systemId A const XMLCh pointer to the Unicode string which
  677.       *                 contains the path to the XML file to be parsed.
  678.       *
  679.       * @exception SAXException Any SAX exception, possibly
  680.       *            wrapping another exception.
  681.       * @exception XMLException An exception from the parser or client
  682.       *            handler code.
  683.       * @exception DOMException A DOM exception as per DOM spec.
  684.       * @see #parse(InputSource,...)
  685.       */
  686.     void parse(const XMLCh* const systemId);
  687.     /** Parse via a file path or URL (in the local code page)
  688.       *
  689.       * This method invokes the parsing process on the XML file specified by
  690.       * the native char* string parameter 'systemId'.
  691.       *
  692.       * @param systemId A const char pointer to a native string which
  693.       *                 contains the path to the XML file to be parsed.
  694.       *
  695.       * @exception SAXException Any SAX exception, possibly
  696.       *            wrapping another exception.
  697.       * @exception XMLException An exception from the parser or client
  698.       *            handler code.
  699.       * @exception DOMException A DOM exception as per DOM spec.
  700.       * @see #parse(InputSource,...)
  701.       */
  702.     void parse(const char* const systemId);
  703.     /** Begin a progressive parse operation
  704.       *
  705.       * This method is used to start a progressive parse on a XML file.
  706.       * To continue parsing, subsequent calls must be to the parseNext
  707.       * method.
  708.       *
  709.       * It scans through the prolog and returns a token to be used on
  710.       * subsequent scanNext() calls. If the return value is true, then the
  711.       * token is legal and ready for further use. If it returns false, then
  712.       * the scan of the prolog failed and the token is not going to work on
  713.       * subsequent scanNext() calls.
  714.       *
  715.       * @param systemId A pointer to a Unicode string represting the path
  716.       *                 to the XML file to be parsed.
  717.       * @param toFill   A token maintaing state information to maintain
  718.       *                 internal consistency between invocation of 'parseNext'
  719.       *                 calls.
  720.       * @return 'true', if successful in parsing the prolog. It indicates the
  721.       *         user can go ahead with parsing the rest of the file. It
  722.       *         returns 'false' to indicate that the parser could not parse
  723.       *         the prolog.
  724.       *
  725.       * @see #parseNext
  726.       * @see #parseFirst(char*,...)
  727.       * @see #parseFirst(InputSource&,...)
  728.       */
  729.     bool parseFirst
  730.     (
  731.         const   XMLCh* const    systemId
  732.         ,       XMLPScanToken&  toFill
  733.     );
  734.     /** Begin a progressive parse operation
  735.       *
  736.       * This method is used to start a progressive parse on a XML file.
  737.       * To continue parsing, subsequent calls must be to the parseNext
  738.       * method.
  739.       *
  740.       * It scans through the prolog and returns a token to be used on
  741.       * subsequent scanNext() calls. If the return value is true, then the
  742.       * token is legal and ready for further use. If it returns false, then
  743.       * the scan of the prolog failed and the token is not going to work on
  744.       * subsequent scanNext() calls.
  745.       *
  746.       * @param systemId A pointer to a regular native string represting
  747.       *                 the path to the XML file to be parsed.
  748.       * @param toFill   A token maintaing state information to maintain
  749.       *                 internal consistency between invocation of 'parseNext'
  750.       *                 calls.
  751.       *
  752.       * @return 'true', if successful in parsing the prolog. It indicates the
  753.       *         user can go ahead with parsing the rest of the file. It
  754.       *         returns 'false' to indicate that the parser could not parse
  755.       *         the prolog.
  756.       *
  757.       * @see #parseNext
  758.       * @see #parseFirst(XMLCh*,...)
  759.       * @see #parseFirst(InputSource&,...)
  760.       */
  761.     bool parseFirst
  762.     (
  763.         const   char* const     systemId
  764.         ,       XMLPScanToken&  toFill
  765.     );
  766.     /** Begin a progressive parse operation
  767.       *
  768.       * This method is used to start a progressive parse on a XML file.
  769.       * To continue parsing, subsequent calls must be to the parseNext
  770.       * method.
  771.       *
  772.       * It scans through the prolog and returns a token to be used on
  773.       * subsequent scanNext() calls. If the return value is true, then the
  774.       * token is legal and ready for further use. If it returns false, then
  775.       * the scan of the prolog failed and the token is not going to work on
  776.       * subsequent scanNext() calls.
  777.       *
  778.       * @param source   A const reference to the InputSource object which
  779.       *                 points to the XML file to be parsed.
  780.       * @param toFill   A token maintaing state information to maintain
  781.       *                 internal consistency between invocation of 'parseNext'
  782.       *                 calls.
  783.       *
  784.       * @return 'true', if successful in parsing the prolog. It indicates the
  785.       *         user can go ahead with parsing the rest of the file. It
  786.       *         returns 'false' to indicate that the parser could not parse
  787.       *         the prolog.
  788.       *
  789.       * @see #parseNext
  790.       * @see #parseFirst(XMLCh*,...)
  791.       * @see #parseFirst(char*,...)
  792.       */
  793.     bool parseFirst
  794.     (
  795.         const   InputSource&    source
  796.         ,       XMLPScanToken&  toFill
  797.     );
  798.     /** Continue a progressive parse operation
  799.       *
  800.       * This method is used to continue with progressive parsing of
  801.       * XML files started by a call to 'parseFirst' method.
  802.       *
  803.       * It parses the XML file and stops as soon as it comes across
  804.       * a XML token (as defined in the XML specification).
  805.       *
  806.       * @param token A token maintaing state information to maintain
  807.       *              internal consistency between invocation of 'parseNext'
  808.       *              calls.
  809.       *
  810.       * @return 'true', if successful in parsing the next XML token.
  811.       *         It indicates the user can go ahead with parsing the rest
  812.       *         of the file. It returns 'false' to indicate that the parser
  813.       *         could not find next token as per the XML specification
  814.       *         production rule.
  815.       *
  816.       * @see #parseFirst(XMLCh*,...)
  817.       * @see #parseFirst(char*,...)
  818.       * @see #parseFirst(InputSource&,...)
  819.       */
  820.     bool parseNext(XMLPScanToken& token);
  821.     /** Reset the parser after a progressive parse
  822.       *
  823.       * If a progressive parse loop exits before the end of the document
  824.       * is reached, the parser has no way of knowing this. So it will leave
  825.       * open any files or sockets or memory buffers that were in use at
  826.       * the time that the parse loop exited.
  827.       *
  828.       * The next parse operation will cause these open files and such to
  829.       * be closed, but the next parse operation might occur at some unknown
  830.       * future point. To avoid this problem, you should reset the parser if
  831.       * you exit the loop early.
  832.       *
  833.       * If you exited because of an error, then this cleanup will be done
  834.       * for you. Its only when you exit the file prematurely of your own
  835.       * accord, because you've found what you wanted in the file most
  836.       * likely.
  837.       *
  838.       * @param token A token maintaing state information to maintain
  839.       *              internal consistency between invocation of 'parseNext'
  840.       *              calls.
  841.       *
  842.       * @see #parseFirst(XMLCh*,...)
  843.       * @see #parseFirst(char*,...)
  844.       * @see #parseFirst(InputSource&,...)
  845.       */
  846.     void parseReset(XMLPScanToken& token);
  847.     //@}
  848.     // -----------------------------------------------------------------------
  849.     //  Implementation of the XMLDocumentHandler interface.
  850.     // -----------------------------------------------------------------------
  851.     /** @name Implementation of the XMLDocumentHandler interface. */
  852.     //@{
  853.     /** Handle document character events
  854.       *
  855.       * This method is used to report all the characters scanned by the
  856.       * parser. This DOM implementation stores this data in the appropriate
  857.       * DOM node, creating one if necessary.
  858.       *
  859.       * @param chars   A const pointer to a Unicode string representing the
  860.       *                character data.
  861.       * @param length  The length of the Unicode string returned in 'chars'.
  862.       * @param cdataSection  A flag indicating if the characters represent
  863.       *                      content from the CDATA section.
  864.       */
  865.     virtual void docCharacters
  866.     (
  867.         const   XMLCh* const    chars
  868.         , const unsigned int    length
  869.         , const bool            cdataSection
  870.     );
  871.     /** Handle a document comment event
  872.       *
  873.       * This method is used to report any comments scanned by the parser.
  874.       * A new comment node is created which stores this data.
  875.       *
  876.       * @param comment A const pointer to a null terminated Unicode
  877.       *                string representing the comment text.
  878.       */
  879.     virtual void docComment
  880.     (
  881.         const   XMLCh* const    comment
  882.     );
  883.     /** Handle a document PI event
  884.       *
  885.       * This method is used to report any PI scanned by the parser. A new
  886.       * PI node is created and appended as a child of the current node in
  887.       * the tree.
  888.       *
  889.       * @param target A const pointer to a Unicode string representing the
  890.       *               target of the PI declaration.
  891.       * @param data   A const pointer to a Unicode string representing the
  892.       *               data of the PI declaration. See the PI production rule
  893.       *               in the XML specification for details.
  894.       */
  895.     virtual void docPI
  896.     (
  897.         const   XMLCh* const    target
  898.         , const XMLCh* const    data
  899.     );
  900.     /** Handle the end of document event
  901.       *
  902.       * This method is used to indicate the end of the current document.
  903.       */
  904.     virtual void endDocument();
  905.     /** Handle and end of element event
  906.       *
  907.       * This method is used to indicate the end tag of an element. The
  908.       * DOM parser pops the current element off the top of the element
  909.       * stack, and make it the new current element.
  910.       *
  911.       * @param elemDecl A const reference to the object containing element
  912.       *                 declaration information.
  913.       * @param urlId    An id referring to the namespace prefix, if
  914.       *                 namespaces setting is switched on.
  915.       * @param isRoot   A flag indicating whether this element was the
  916.       *                 root element.
  917.       * @param elemPrefix A const pointer to a Unicode string containing
  918.       *                 the namespace prefix for this element. Applicable
  919.       *                 only when namespace processing is enabled.
  920.       */
  921.     virtual void endElement
  922.     (
  923.         const   XMLElementDecl& elemDecl
  924.         , const unsigned int    urlId
  925.         , const bool            isRoot
  926.         , const XMLCh* const    elemPrefix
  927.     );
  928.     /** Handle and end of entity reference event
  929.       *
  930.       * This method is used to indicate that an end of an entity reference
  931.       * was just scanned.
  932.       *
  933.       * @param entDecl A const reference to the object containing the
  934.       *                entity declaration information.
  935.       */
  936.     virtual void endEntityReference
  937.     (
  938.         const   XMLEntityDecl&  entDecl
  939.     );
  940.     /** Handle an ignorable whitespace vent
  941.       *
  942.       * This method is used to report all the whitespace characters, which
  943.       * are determined to be 'ignorable'. This distinction between characters
  944.       * is only made, if validation is enabled.
  945.       *
  946.       * Any whitespace before content is ignored. If the current node is
  947.       * already of type DOMNode::TEXT_NODE, then these whitespaces are
  948.       * appended, otherwise a new Text node is created which stores this
  949.       * data. Essentially all contiguous ignorable characters are collected
  950.       * in one node.
  951.       *
  952.       * @param chars   A const pointer to a Unicode string representing the
  953.       *                ignorable whitespace character data.
  954.       * @param length  The length of the Unicode string 'chars'.
  955.       * @param cdataSection  A flag indicating if the characters represent
  956.       *                      content from the CDATA section.
  957.       */
  958.     virtual void ignorableWhitespace
  959.     (
  960.         const   XMLCh* const    chars
  961.         , const unsigned int    length
  962.         , const bool            cdataSection
  963.     );
  964.     /** Handle a document reset event
  965.       *
  966.       * This method allows the user installed Document Handler to 'reset'
  967.       * itself, freeing all the memory resources. The scanner calls this
  968.       * method before starting a new parse event.
  969.       */
  970.     virtual void resetDocument();
  971.     /** Handle a start document event
  972.       *
  973.       * This method is used to report the start of the parsing process.
  974.       */
  975.     virtual void startDocument();
  976.     /** Handle a start element event
  977.       *
  978.       * This method is used to report the start of an element. It is
  979.       * called at the end of the element, by which time all attributes
  980.       * specified are also parsed. A new DOM Element node is created
  981.       * along with as many attribute nodes as required. This new element
  982.       * is added appended as a child of the current node in the tree, and
  983.       * then replaces it as the current node (if the isEmpty flag is false.)
  984.       *
  985.       * @param elemDecl A const reference to the object containing element
  986.       *                 declaration information.
  987.       * @param urlId    An id referring to the namespace prefix, if
  988.       *                 namespaces setting is switched on.
  989.       * @param elemPrefix A const pointer to a Unicode string containing
  990.       *                 the namespace prefix for this element. Applicable
  991.       *                 only when namespace processing is enabled.
  992.       * @param attrList A const reference to the object containing the
  993.       *                 list of attributes just scanned for this element.
  994.       * @param attrCount A count of number of attributes in the list
  995.       *                 specified by the parameter 'attrList'.
  996.       * @param isEmpty  A flag indicating whether this is an empty element
  997.       *                 or not. If empty, then no endElement() call will
  998.       *                 be made.
  999.       * @param isRoot   A flag indicating whether this element was the
  1000.       *                 root element.
  1001.       * @see DocumentHandler#startElement
  1002.       */
  1003.     virtual void startElement
  1004.     (
  1005.         const   XMLElementDecl&         elemDecl
  1006.         , const unsigned int            urlId
  1007.         , const XMLCh* const            elemPrefix
  1008.         , const RefVectorOf<XMLAttr>&   attrList
  1009.         , const unsigned int            attrCount
  1010.         , const bool                    isEmpty
  1011.         , const bool                    isRoot
  1012.     );
  1013.     /** Handle a start entity reference event
  1014.       *
  1015.       * This method is used to indicate the start of an entity reference.
  1016.       * If the expand entity reference flag is true, then a new
  1017.       * DOM Entity reference node is created.
  1018.       *
  1019.       * @param entDecl A const reference to the object containing the
  1020.       *                entity declaration information.
  1021.       */
  1022.     virtual void startEntityReference
  1023.     (
  1024.         const   XMLEntityDecl&  entDecl
  1025.     );
  1026.     /** Handle an XMLDecl event
  1027.       *
  1028.       * This method is used to report the XML decl scanned by the parser.
  1029.       * Refer to the XML specification to see the meaning of parameters.
  1030.       *
  1031.       * <b><font color="#FF0000">This method is a no-op for this DOM
  1032.       * implementation.</font></b>
  1033.       *
  1034.       * @param versionStr A const pointer to a Unicode string representing
  1035.       *                   version string value.
  1036.       * @param encodingStr A const pointer to a Unicode string representing
  1037.       *                    the encoding string value.
  1038.       * @param standaloneStr A const pointer to a Unicode string
  1039.       *                      representing the standalone string value.
  1040.       * @param actualEncStr A const pointer to a Unicode string
  1041.       *                     representing the actual encoding string
  1042.       *                     value.
  1043.       */
  1044.     virtual void XMLDecl
  1045.     (
  1046.         const   XMLCh* const    versionStr
  1047.         , const XMLCh* const    encodingStr
  1048.         , const XMLCh* const    standaloneStr
  1049.         , const XMLCh* const    actualEncStr
  1050.     );
  1051.     //@}
  1052.     // -----------------------------------------------------------------------
  1053.     //  Implementation of the deprecated DocTypeHandler interface.
  1054.     // -----------------------------------------------------------------------
  1055.     /** @name Deprecated DocTypeHandler Interfaces */
  1056.     //@{
  1057.     virtual void attDef
  1058.     (
  1059.         const   DTDElementDecl&     elemDecl
  1060.         , const DTDAttDef&          attDef
  1061.         , const bool                ignoring
  1062.     );
  1063.     virtual void doctypeComment
  1064.     (
  1065.         const   XMLCh* const    comment
  1066.     );
  1067.     virtual void doctypeDecl
  1068.     (
  1069.         const   DTDElementDecl& elemDecl
  1070.         , const XMLCh* const    publicId
  1071.         , const XMLCh* const    systemId
  1072.         , const bool            hasIntSubset
  1073.         , const bool            hasExtSubset = false
  1074.     );
  1075.     virtual void doctypePI
  1076.     (
  1077.         const   XMLCh* const    target
  1078.         , const XMLCh* const    data
  1079.     );
  1080.     virtual void doctypeWhitespace
  1081.     (
  1082.         const   XMLCh* const    chars
  1083.         , const unsigned int    length
  1084.     );
  1085.     virtual void elementDecl
  1086.     (
  1087.         const   DTDElementDecl& decl
  1088.         , const bool            isIgnored
  1089.     );
  1090.     virtual void endAttList
  1091.     (
  1092.         const   DTDElementDecl& elemDecl
  1093.     );
  1094.     virtual void endIntSubset();
  1095.     virtual void endExtSubset();
  1096.     virtual void entityDecl
  1097.     (
  1098.         const   DTDEntityDecl&  entityDecl
  1099.         , const bool            isPEDecl
  1100.         , const bool            isIgnored
  1101.     );
  1102.     virtual void resetDocType();
  1103.     virtual void notationDecl
  1104.     (
  1105.         const   XMLNotationDecl&    notDecl
  1106.         , const bool                isIgnored
  1107.     );
  1108.     virtual void startAttList
  1109.     (
  1110.         const   DTDElementDecl& elemDecl
  1111.     );
  1112.     virtual void startIntSubset();
  1113.     virtual void startExtSubset();
  1114.     virtual void TextDecl
  1115.     (
  1116.         const   XMLCh* const    versionStr
  1117.         , const XMLCh* const    encodingStr
  1118.     );
  1119.     //@}
  1120.     // -----------------------------------------------------------------------
  1121.     //  Deprecated Methods
  1122.     // -----------------------------------------------------------------------
  1123.     /** @name Deprecated Methods */
  1124.     //@{
  1125.     /**
  1126.       * This method returns the state of the parser's validation
  1127.       * handling flag which controls whether validation checks
  1128.       * are enforced or not.
  1129.       *
  1130.       * @return true, if the parser is currently configured to
  1131.       *         do validation, false otherwise.
  1132.       *
  1133.       * @see #setDoValidation
  1134.       */
  1135.     bool getDoValidation() const;
  1136.     /**
  1137.       * This method allows users to enable or disable the parser's validation
  1138.       * checks.
  1139.       *
  1140.       * <p>By default, the parser does not to any validation. The default
  1141.       * value is false.</p>
  1142.       *
  1143.       * @param newState The value specifying whether the parser should
  1144.       *                 do validity checks or not against the DTD in the
  1145.       *                 input XML document.
  1146.       *
  1147.       * @see #getDoValidation
  1148.       */
  1149.     void setDoValidation(const bool newState);
  1150.     /** Get the 'expand entity references' flag.
  1151.       * DEPRECATED Use getCreateEntityReferenceNodes() instead.
  1152.       *
  1153.       * This method returns the state of the parser's expand entity
  1154.       * references flag.
  1155.       *
  1156.       * @return 'true' if the expand entity reference flag is set on
  1157.       *         the parser, 'false' otherwise.
  1158.       *
  1159.       * @see #setExpandEntityReferences
  1160.       * @see #setCreateEntityReferenceNodes
  1161.       * @see #getCreateEntityReferenceNodes
  1162.       */
  1163.     bool getExpandEntityReferences() const;
  1164.     /** Set the 'expand entity references' flag
  1165.       *
  1166.       * DEPRECATED.  USE setCreateEntityReferenceNodes instead.
  1167.       * This method allows the user to specify whether the parser should
  1168.       * expand all entity reference nodes. When the 'do expansion' flag is
  1169.       * true, the DOM tree does not have any entity reference nodes. It is
  1170.       * replaced by the sub-tree representing the replacement text of the
  1171.       * entity. When the 'do expansion' flag is false, the DOM tree
  1172.       * contains an extra entity reference node, whose children is the
  1173.       * sub tree of the replacement text.
  1174.       * <p>The default value is 'false'.
  1175.       *
  1176.       * @param expand The new state of the expand entity reference
  1177.       *               flag.
  1178.       * @see #setCreateEntityReferenceNodes
  1179.       */
  1180.     void setExpandEntityReferences(const bool expand);
  1181.     //@}
  1182. protected :
  1183.     // -----------------------------------------------------------------------
  1184.     //  Protected Constructor Methods
  1185.     // -----------------------------------------------------------------------
  1186.     /** @name Constructors */
  1187.     //@{
  1188.     /** Construct a AbstractDOMParser, with an optional validator
  1189.       *
  1190.       * Constructor with an instance of validator class to use for
  1191.       * validation. If you don't provide a validator, a default one will
  1192.       * be created for you in the scanner.
  1193.       *
  1194.       * @param valToAdopt Pointer to the validator instance to use. The
  1195.       *                   parser is responsible for freeing the memory.
  1196.       */
  1197.     AbstractDOMParser
  1198.     (
  1199.           XMLValidator* const valToAdopt = 0
  1200.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  1201.     );
  1202.     //@}
  1203.     // -----------------------------------------------------------------------
  1204.     //  Protected getter methods
  1205.     // -----------------------------------------------------------------------
  1206.     /** @name Protected getter methods */
  1207.     //@{
  1208.     /** Get the current DOM node
  1209.       *
  1210.       * This provides derived classes with access to the current node, i.e.
  1211.       * the node to which new nodes are being added.
  1212.       */
  1213.     DOMNode* getCurrentNode();
  1214.     /** Get the XML scanner
  1215.       *
  1216.       * This provides derived classes with access to the XML scanner.
  1217.       */
  1218.     XMLScanner* getScanner() const;
  1219.     /** Get the Grammar resolver
  1220.       *
  1221.       * This provides derived classes with access to the grammar resolver.
  1222.       */
  1223.     GrammarResolver* getGrammarResolver() const;
  1224.     /** Get the parse in progress flag
  1225.       *
  1226.       * This provides derived classes with access to the parse in progress
  1227.       * flag.
  1228.       */
  1229.     bool getParseInProgress() const;
  1230.     MemoryManager* getMemoryManager() const;
  1231.     //@}
  1232.     // -----------------------------------------------------------------------
  1233.     //  Protected setter methods
  1234.     // -----------------------------------------------------------------------
  1235.     /** @name Protected setter methods */
  1236.     //@{
  1237.     /** Set the current DOM node
  1238.       *
  1239.       * This method sets the current node maintained inside the parser to
  1240.       * the one specified.
  1241.       *
  1242.       * @param toSet The DOM node which will be the current node.
  1243.       */
  1244.     void setCurrentNode(DOMNode* toSet);
  1245.     /** Set the document node
  1246.       *
  1247.       * This method sets the DOM Document node to the one specified.
  1248.       *
  1249.       * @param toSet The new DOM Document node for this XML document.
  1250.       */
  1251.     void setDocument(DOMDocument* toSet);
  1252.     /** Set the parse in progress flag
  1253.       *
  1254.       * This method sets the parse in progress flag to true or false.
  1255.       *
  1256.       * @param toSet The value of the flag to be set.
  1257.       */
  1258.     void setParseInProgress(const bool toSet);
  1259.     //@}
  1260.     // -----------------------------------------------------------------------
  1261.     //  Protected Helper methods
  1262.     // -----------------------------------------------------------------------
  1263.     /** @name Protected helper methods */
  1264.     //@{
  1265.     virtual DOMElement* createElementNSNode(const XMLCh *fNamespaceURI,
  1266.                                               const XMLCh *qualifiedName);
  1267.     void resetPool();
  1268.     /**
  1269.      * Returns true if the user has adopted the document
  1270.      */
  1271.     bool isDocumentAdopted() const;
  1272.     //@}
  1273. private :
  1274.     // -----------------------------------------------------------------------
  1275.     //  Initialize/Cleanup methods
  1276.     // -----------------------------------------------------------------------
  1277.     void initialize();
  1278.     void cleanUp();
  1279.     // -----------------------------------------------------------------------
  1280.     //  Private data members
  1281.     //
  1282.     //  fCurrentNode
  1283.     //  fCurrentParent
  1284.     //      Used to track the current node during nested element events. Since
  1285.     //      the tree must be built from a set of disjoint callbacks, we need
  1286.     //      these to keep up with where we currently are.
  1287.     //
  1288.     //  fCurrentEntity
  1289.     //      Used to track the current entity decl.  If a text decl is seen later on,
  1290.     //      it is used to update the encoding and version information.
  1291.     //
  1292.     //  fDocument
  1293.     //      The root document object, filled with the document contents.
  1294.     //
  1295.     //  fCreateEntityReferenceNodes
  1296.     //      Indicates whether entity reference nodes should be created.
  1297.     //
  1298.     //  fIncludeIgnorableWhitespace
  1299.     //      Indicates whether ignorable whiltespace should be added to
  1300.     //      the DOM tree for validating parsers.
  1301.     //
  1302.     //  fScanner
  1303.     //      The scanner used for this parser. This is created during the
  1304.     //      constructor.
  1305.     //
  1306.     //  fNodeStack
  1307.     //      Used to track previous parent nodes during nested element events.
  1308.     //
  1309.     //  fParseInProgress
  1310.     //      Used to prevent multiple entrance to the parser while its doing
  1311.     //      a parse.
  1312.     //
  1313.     //  fWithinElement
  1314.     //      A flag to indicate that the parser is within at least one level
  1315.     //      of element processing.
  1316.     //
  1317.     //  fDocumentType
  1318.     //      Used to store and update the documentType variable information
  1319.     //      in fDocument
  1320.     //
  1321.     //  fDocumentVector
  1322.     //      Store all the previous fDocument(s) (thus not the current fDocument)
  1323.     //      created in this parser.  It is destroyed when the parser is destructed.
  1324.     //
  1325.     //  fCreateCommentNodes
  1326.     //      Indicates whether comment nodes should be created.
  1327.     //
  1328.     //  fDocumentAdoptedByUser
  1329.     //      The DOMDocument ownership has been transferred to application
  1330.     //      If set to true, the parser does not own the document anymore
  1331.     //      and thus will not release its memory.
  1332.     //
  1333.     //  fInternalSubset
  1334.     //      Buffer for storing the internal subset information.
  1335.     //      Once complete (after DOCTYPE is finished scanning), send
  1336.     //      it to DocumentType Node
  1337.     // -----------------------------------------------------------------------
  1338.     bool                          fCreateEntityReferenceNodes;
  1339.     bool                          fIncludeIgnorableWhitespace;
  1340.     bool                          fWithinElement;
  1341.     bool                          fParseInProgress;
  1342.     bool                          fCreateCommentNodes;
  1343.     bool                          fDocumentAdoptedByUser;
  1344.     XMLScanner*                   fScanner;
  1345.     DOMNode*                      fCurrentParent;
  1346.     DOMNode*                      fCurrentNode;
  1347.     DOMEntity*                    fCurrentEntity;
  1348.     DOMDocumentImpl*              fDocument;
  1349.     ValueStackOf<DOMNode*>*       fNodeStack;
  1350.     DOMDocumentTypeImpl*          fDocumentType;
  1351.     RefVectorOf<DOMDocumentImpl>* fDocumentVector;
  1352.     GrammarResolver*              fGrammarResolver;
  1353.     XMLStringPool*                fURIStringPool;
  1354.     XMLValidator*                 fValidator;
  1355.     MemoryManager*                fMemoryManager;
  1356.     XMLBufferMgr                  fBufMgr;
  1357.     XMLBuffer&                    fInternalSubset;
  1358. };
  1359. // ---------------------------------------------------------------------------
  1360. //  AbstractDOMParser: Getter methods
  1361. // ---------------------------------------------------------------------------
  1362. inline bool AbstractDOMParser::getExpandEntityReferences() const
  1363. {
  1364.     return !fCreateEntityReferenceNodes;
  1365. }
  1366. inline bool AbstractDOMParser::getCreateEntityReferenceNodes() const
  1367. {
  1368.     return fCreateEntityReferenceNodes;
  1369. }
  1370. inline bool AbstractDOMParser::getIncludeIgnorableWhitespace() const
  1371. {
  1372.     return fIncludeIgnorableWhitespace;
  1373. }
  1374. inline bool AbstractDOMParser::getParseInProgress() const
  1375. {
  1376.     return fParseInProgress;
  1377. }
  1378. inline XMLScanner* AbstractDOMParser::getScanner() const
  1379. {
  1380.     return fScanner;
  1381. }
  1382. inline GrammarResolver* AbstractDOMParser::getGrammarResolver() const
  1383. {
  1384.     return fGrammarResolver;
  1385. }
  1386. inline bool AbstractDOMParser::getCreateCommentNodes() const
  1387. {
  1388.     return fCreateCommentNodes;
  1389. }
  1390. // ---------------------------------------------------------------------------
  1391. //  AbstractDOMParser: Setter methods
  1392. // ---------------------------------------------------------------------------
  1393. inline void AbstractDOMParser::setExpandEntityReferences(const bool expand)
  1394. {
  1395.     fCreateEntityReferenceNodes = !expand;
  1396. }
  1397. inline void AbstractDOMParser::setCreateEntityReferenceNodes(const bool create)
  1398. {
  1399.     fCreateEntityReferenceNodes = create;
  1400. }
  1401. inline void AbstractDOMParser::setIncludeIgnorableWhitespace(const bool include)
  1402. {
  1403.     fIncludeIgnorableWhitespace = include;
  1404. }
  1405. inline void AbstractDOMParser::setCreateCommentNodes(const bool create)
  1406. {
  1407.     fCreateCommentNodes = create;
  1408. }
  1409. // ---------------------------------------------------------------------------
  1410. //  AbstractDOMParser: Protected getter methods
  1411. // ---------------------------------------------------------------------------
  1412. inline DOMNode* AbstractDOMParser::getCurrentNode()
  1413. {
  1414.     return fCurrentNode;
  1415. }
  1416. inline MemoryManager* AbstractDOMParser::getMemoryManager() const
  1417. {
  1418.     return fMemoryManager;
  1419. }
  1420. // ---------------------------------------------------------------------------
  1421. //  AbstractDOMParser: Protected setter methods
  1422. // ---------------------------------------------------------------------------
  1423. inline void AbstractDOMParser::setCurrentNode(DOMNode* toSet)
  1424. {
  1425.     fCurrentNode = toSet;
  1426. }
  1427. inline void AbstractDOMParser::setDocument(DOMDocument* toSet)
  1428. {
  1429.     fDocument = (DOMDocumentImpl *)toSet;
  1430. }
  1431. inline void AbstractDOMParser::setParseInProgress(const bool toSet)
  1432. {
  1433.     fParseInProgress = toSet;
  1434. }
  1435. XERCES_CPP_NAMESPACE_END
  1436. #endif