开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
SchemaGrammar.hpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：21k
源码类别：

词法分析

开发平台：

Visual C++

SchemaGrammar.hpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 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.  */
  57. /*
  58.  * $Log: SchemaGrammar.hpp,v $
  59.  * Revision 1.7  2003/05/16 21:43:21  knoaman
  60.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  61.  *
  62.  * Revision 1.6  2003/05/15 18:57:27  knoaman
  63.  * Partial implementation of the configurable memory manager.
  64.  *
  65.  * Revision 1.5  2002/11/04 14:49:41  tng
  66.  * C++ Namespace Support.
  67.  *
  68.  * Revision 1.4  2002/08/22 15:42:10  tng
  69.  * Remove unused parameter variables in inline functions.
  70.  *
  71.  * Revision 1.3  2002/07/11 18:21:20  knoaman
  72.  * Grammar caching/preparsing - initial implementation.
  73.  *
  74.  * Revision 1.2  2002/07/05 17:08:10  tng
  75.  * [Bug 10119] Grammar::getGrammarType need a const modifier
  76.  *
  77.  * Revision 1.1.1.1  2002/02/01 22:22:46  peiyongz
  78.  * sane_include
  79.  *
  80.  * Revision 1.14  2001/11/19 18:26:31  knoaman
  81.  * no message
  82.  *
  83.  * Revision 1.13  2001/10/09 12:18:26  tng
  84.  * Leak fix: should use delete [] to delete fTargetNamespace.
  85.  *
  86.  * Revision 1.12  2001/10/04 15:11:51  knoaman
  87.  * Add support for circular import.
  88.  *
  89.  * Revision 1.10  2001/09/14 14:50:22  tng
  90.  * Schema: Fix some wildcard bugs, and some retrieving qualified/unqualified element decl problems.
  91.  *
  92.  * Revision 1.9  2001/08/21 16:06:11  tng
  93.  * Schema: Unique Particle Attribution Constraint Checking.
  94.  *
  95.  * Revision 1.8  2001/07/31 15:27:10  knoaman
  96.  * Added support for <attributeGroup>.
  97.  *
  98.  * Revision 1.7  2001/07/24 18:33:46  knoaman
  99.  * Added support for <group> + extra constraint checking for complexType
  100.  *
  101.  * Revision 1.6  2001/06/25 12:51:57  knoaman
  102.  * Add constraint checking on elements in complex types to prevent same
  103.  * element names from having different definitions - use substitueGroups.
  104.  *
  105.  * Revision 1.5  2001/05/28 20:56:19  tng
  106.  * Schema: Move getTargetNamespace as virtual function in base class Grammar
  107.  *
  108.  * Revision 1.4  2001/05/11 13:27:36  tng
  109.  * Copyright update.
  110.  *
  111.  * Revision 1.3  2001/05/03 20:34:43  tng
  112.  * Schema: SchemaValidator update
  113.  *
  114.  * Revision 1.2  2001/04/19 17:43:19  knoaman
  115.  * More schema implementation classes.
  116.  *
  117.  * Revision 1.1  2001/03/21 21:56:33  tng
  118.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  119.  *
  120.  */
  124. #if !defined(SCHEMAGRAMMAR_HPP)
  125. #define SCHEMAGRAMMAR_HPP
  127. #include <xercesc/framework/XMLNotationDecl.hpp>
  128. #include <xercesc/util/RefHash3KeysIdPool.hpp>
  129. #include <xercesc/util/NameIdPool.hpp>
  130. #include <xercesc/util/StringPool.hpp>
  131. #include <xercesc/validators/common/Grammar.hpp>
  132. #include <xercesc/validators/schema/SchemaElementDecl.hpp>
  133. #include <xercesc/util/ValueVectorOf.hpp>
  134. #include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
  135. #include <xercesc/validators/datatype/DatatypeValidatorFactory.hpp>
  137. XERCES_CPP_NAMESPACE_BEGIN
  139. //
  140. // This class stores the Schema information
  141. //  NOTE: Schemas are not namespace aware, so we just use regular NameIdPool
  142. //  data structures to store element and attribute decls. They are all set
  143. //  to be in the global namespace and the full QName is used as the base name
  144. //  of the decl. This means that all the URI parameters below are expected
  145. //  to be null pointers (and anything else will cause an exception.)
  146. //
  148. // ---------------------------------------------------------------------------
  149. //  Forward Declarations
  150. // ---------------------------------------------------------------------------
  151. class ComplexTypeInfo;
  152. class NamespaceScope;
  153. class XercesGroupInfo;
  154. class XercesAttGroupInfo;
  156. // ---------------------------------------------------------------------------
  157. //  typedef declaration
  158. // ---------------------------------------------------------------------------
  159. typedef ValueVectorOf<SchemaElementDecl*> ElemVector;
  162. class VALIDATORS_EXPORT SchemaGrammar : public Grammar
  163. {
  164. public:
  165.     // -----------------------------------------------------------------------
  166.     //  Constructors and Destructor
  167.     // -----------------------------------------------------------------------
  168.     SchemaGrammar(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  169.     virtual ~SchemaGrammar();
  171.     // -----------------------------------------------------------------------
  172.     //  Implementation of Virtual Interface
  173.     // -----------------------------------------------------------------------
  174.     virtual Grammar::GrammarType getGrammarType() const;
  175.     virtual const XMLCh* getTargetNamespace() const;
  177.     virtual XMLElementDecl* findOrAddElemDecl
  178.     (
  179.         const   unsigned int    uriId
  180.         , const XMLCh* const    baseName
  181.         , const XMLCh* const    prefixName
  182.         , const XMLCh* const    qName
  183.         , unsigned int          scope
  184.         ,       bool&           wasAdded
  185.     ) ;
  187.     virtual unsigned int getElemId
  188.     (
  189.         const   unsigned int    uriId
  190.         , const XMLCh* const    baseName
  191.         , const XMLCh* const    qName
  192.         , unsigned int          scope
  193.     )   const ;
  195.     virtual const XMLElementDecl* getElemDecl
  196.     (
  197.         const   unsigned int    uriId
  198.         , const XMLCh* const    baseName
  199.         , const XMLCh* const    qName
  200.         , unsigned int          scope
  201.     )   const ;
  203.     virtual XMLElementDecl* getElemDecl
  204.     (
  205.         const   unsigned int    uriId
  206.         , const XMLCh* const    baseName
  207.         , const XMLCh* const    qName
  208.         , unsigned int          scope
  209.     );
  211.     virtual const XMLElementDecl* getElemDecl
  212.     (
  213.         const   unsigned int    elemId
  214.     )   const;
  216.     virtual XMLElementDecl* getElemDecl
  217.     (
  218.         const   unsigned int    elemId
  219.     );
  221.     virtual const XMLNotationDecl* getNotationDecl
  222.     (
  223.         const   XMLCh* const    notName
  224.     )   const;
  226.     virtual XMLNotationDecl* getNotationDecl
  227.     (
  228.         const   XMLCh* const    notName
  229.     );
  231.     virtual bool getValidated() const;
  233.     virtual XMLElementDecl* putElemDecl
  234.     (
  235.         const   unsigned int    uriId
  236.         , const XMLCh* const    baseName
  237.         , const XMLCh* const    prefixName
  238.         , const XMLCh* const    qName
  239.         , unsigned int          scope
  240.         , const bool            notDeclared = false
  241.     );
  243.     virtual unsigned int putElemDecl
  244.     (
  245.         XMLElementDecl* const elemDecl
  246.         , const bool          notDeclared = false
  247.     )   const;
  249.     virtual unsigned int putNotationDecl
  250.     (
  251.         XMLNotationDecl* const notationDecl
  252.     )   const;
  254.     virtual void setValidated(const bool newState);
  256.     virtual void reset();
  258.     // -----------------------------------------------------------------------
  259.     //  Getter methods
  260.     // -----------------------------------------------------------------------
  261.     RefHash3KeysIdPoolEnumerator<SchemaElementDecl> getElemEnumerator() const;
  262.     RefHashTableOf<XMLAttDef>* getAttributeDeclRegistry() const;
  263.     RefHashTableOf<ComplexTypeInfo>* getComplexTypeRegistry() const;
  264.     RefHashTableOf<XercesGroupInfo>* getGroupInfoRegistry() const;
  265.     RefHashTableOf<XercesAttGroupInfo>* getAttGroupInfoRegistry() const;
  266.     DatatypeValidatorFactory* getDatatypeRegistry();
  267.     NamespaceScope* getNamespaceScope() const;
  268.     RefHash2KeysTableOf<ElemVector>* getValidSubstitutionGroups() const;
  269.     RefHashTableOf<XMLRefInfo>* getIDRefList() const;
  271.     // -----------------------------------------------------------------------
  272.     //  Setter methods
  273.     // -----------------------------------------------------------------------
  274.     void setTargetNamespace(const XMLCh* const targetNamespace);
  275.     void setAttributeDeclRegistry(RefHashTableOf<XMLAttDef>* const attReg);
  276.     void setComplexTypeRegistry(RefHashTableOf<ComplexTypeInfo>* const other);
  277.     void setGroupInfoRegistry(RefHashTableOf<XercesGroupInfo>* const other);
  278.     void setAttGroupInfoRegistry(RefHashTableOf<XercesAttGroupInfo>* const other);
  279.     void setNamespaceScope(NamespaceScope* const nsScope);
  280.     void setValidSubstitutionGroups(RefHash2KeysTableOf<ElemVector>* const);
  282.     // -----------------------------------------------------------------------
  283.     //  Helper methods
  284.     // -----------------------------------------------------------------------
  285.     unsigned int putGroupElemDecl
  286.     (
  287.         XMLElementDecl* const elemDecl
  288.     )   const;
  290. private:
  292.     // -----------------------------------------------------------------------
  293.     //  Helper methods
  294.     // -----------------------------------------------------------------------
  295.     void cleanUp();
  297.     // -----------------------------------------------------------------------
  298.     //  Private data members
  299.     //
  300.     //  fElemDeclPool
  301.     //      This is the element decl pool. It contains all of the elements
  302.     //      declared in the Schema (and their associated attributes.)
  303.     //
  304.     //  fElemNonDeclPool
  305.     //      This is the element decl pool that is is populated as new elements
  306.     //      are seen in the XML document (not declared in the Schema), and they
  307.     //      are given default characteristics.
  308.     //
  309.     //  fGroupElemDeclPool
  310.     //      This is the element decl pool for elements in a group that are
  311.     //      referenced in different scope. It contains all of the elements
  312.     //      declared in the Schema (and their associated attributes.)
  313.     //
  314.     //  fNotationDeclPool
  315.     //      This is a pool of NotationDecl objects, which contains all of the
  316.     //      notations declared in the Schema.
  317.     //
  318.     //  fTargetNamespace
  319.     //      Target name space for this grammar.
  320.     //
  321.     //  fAttributeDeclRegistry
  322.     //      Global attribute declarations
  323.     //
  324.     //  fComplexTypeRegistry
  325.     //      Stores complexType declaration info
  326.     //
  327.     //  fGroupInfoRegistry
  328.     //      Stores global <group> declaration info
  329.     //
  330.     //  fAttGroupInfoRegistry
  331.     //      Stores global <attributeGroup> declaration info
  332.     //
  333.     //  fDatatypeRegistry
  334.     //      Datatype validator factory
  335.     //
  336.     //  fNamespaceScope
  337.     //      Prefix to Namespace map
  338.     //
  339.     //  fValidSubstitutionGroups
  340.     //      Valid list of elements that can substitute a given element
  341.     //
  342.     //  fIDRefList
  343.     //      List of ids of schema declarations extracted during schema grammar
  344.     //      traversal
  345.     //
  346.     //  fValidated
  347.     //      Indicates if the content of the Grammar has been pre-validated
  348.     //      or not (UPA checking, etc.). When using a cached grammar, no need
  349.     //      for pre content validation.
  350.     // -----------------------------------------------------------------------
  351.     XMLCh*                                 fTargetNamespace;
  352.     RefHash3KeysIdPool<SchemaElementDecl>* fElemDeclPool;
  353.     RefHash3KeysIdPool<SchemaElementDecl>* fElemNonDeclPool;
  354.     RefHash3KeysIdPool<SchemaElementDecl>* fGroupElemDeclPool;
  355.     NameIdPool<XMLNotationDecl>*           fNotationDeclPool;
  356.     RefHashTableOf<XMLAttDef>*             fAttributeDeclRegistry;
  357.     RefHashTableOf<ComplexTypeInfo>*       fComplexTypeRegistry;
  358.     RefHashTableOf<XercesGroupInfo>*       fGroupInfoRegistry;
  359.     RefHashTableOf<XercesAttGroupInfo>*    fAttGroupInfoRegistry;
  360.     NamespaceScope*                        fNamespaceScope;
  361.     RefHash2KeysTableOf<ElemVector>*       fValidSubstitutionGroups;
  362.     RefHashTableOf<XMLRefInfo>*            fIDRefList;
  363.     MemoryManager*                         fMemoryManager;
  364.     bool                                   fValidated;
  365.     DatatypeValidatorFactory               fDatatypeRegistry;
  366. };
  369. // ---------------------------------------------------------------------------
  370. //  SchemaGrammar: Getter methods
  371. // ---------------------------------------------------------------------------
  372. inline RefHash3KeysIdPoolEnumerator<SchemaElementDecl>
  373. SchemaGrammar::getElemEnumerator() const
  374. {
  375.     return RefHash3KeysIdPoolEnumerator<SchemaElementDecl>(fElemDeclPool);
  376. }
  378. inline RefHashTableOf<XMLAttDef>* SchemaGrammar::getAttributeDeclRegistry() const {
  380.     return fAttributeDeclRegistry;
  381. }
  383. inline RefHashTableOf<ComplexTypeInfo>*
  384. SchemaGrammar::getComplexTypeRegistry() const {
  386.     return fComplexTypeRegistry;
  387. }
  389. inline RefHashTableOf<XercesGroupInfo>*
  390. SchemaGrammar::getGroupInfoRegistry() const {
  392.     return fGroupInfoRegistry;
  393. }
  395. inline RefHashTableOf<XercesAttGroupInfo>*
  396. SchemaGrammar::getAttGroupInfoRegistry() const {
  398.     return fAttGroupInfoRegistry;
  399. }
  401. inline DatatypeValidatorFactory* SchemaGrammar::getDatatypeRegistry() {
  403.     return &fDatatypeRegistry;
  404. }
  406. inline NamespaceScope* SchemaGrammar::getNamespaceScope() const {
  408.     return fNamespaceScope;
  409. }
  411. inline RefHash2KeysTableOf<ElemVector>*
  412. SchemaGrammar::getValidSubstitutionGroups() const {
  414.     return fValidSubstitutionGroups;
  415. }
  417. inline RefHashTableOf<XMLRefInfo>* SchemaGrammar::getIDRefList() const {
  419.     return fIDRefList;
  420. }
  422. // -----------------------------------------------------------------------
  423. //  Setter methods
  424. // -----------------------------------------------------------------------
  425. inline void SchemaGrammar::setTargetNamespace(const XMLCh* const targetNamespace)
  426. {
  427.     if (fTargetNamespace)
  428.         fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace;
  429.     fTargetNamespace = XMLString::replicate(targetNamespace, fMemoryManager);
  430. }
  432. inline void
  433. SchemaGrammar::setAttributeDeclRegistry(RefHashTableOf<XMLAttDef>* const attReg) {
  435.     fAttributeDeclRegistry = attReg;
  436. }
  438. inline void
  439. SchemaGrammar::setComplexTypeRegistry(RefHashTableOf<ComplexTypeInfo>* const other) {
  441.     fComplexTypeRegistry = other;
  442. }
  444. inline void
  445. SchemaGrammar::setGroupInfoRegistry(RefHashTableOf<XercesGroupInfo>* const other) {
  447.     fGroupInfoRegistry = other;
  448. }
  450. inline void
  451. SchemaGrammar::setAttGroupInfoRegistry(RefHashTableOf<XercesAttGroupInfo>* const other) {
  453.     fAttGroupInfoRegistry = other;
  454. }
  456. inline void SchemaGrammar::setNamespaceScope(NamespaceScope* const nsScope) {
  458.     fNamespaceScope = nsScope;
  459. }
  461. inline void
  462. SchemaGrammar::setValidSubstitutionGroups(RefHash2KeysTableOf<ElemVector>* const other) {
  464.     fValidSubstitutionGroups = other;
  465. }
  468. // ---------------------------------------------------------------------------
  469. //  SchemaGrammar: Virtual methods
  470. // ---------------------------------------------------------------------------
  471. inline Grammar::GrammarType SchemaGrammar::getGrammarType() const {
  472.     return Grammar::SchemaGrammarType;
  473. }
  475. inline const XMLCh* SchemaGrammar::getTargetNamespace() const {
  476.     return fTargetNamespace;
  477. }
  479. // Element Decl
  480. inline unsigned int SchemaGrammar::getElemId (const   unsigned int  uriId
  481.                                               , const XMLCh* const    baseName
  482.                                               , const XMLCh* const
  483.                                               , unsigned int          scope ) const
  484. {
  485.     //
  486.     //  In this case, we don't return zero to mean 'not found', so we have to
  487.     //  map it to the official not found value if we don't find it.
  488.     //
  489.     const SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
  490.     if (!decl) {
  492.         decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
  494.         if (!decl)
  495.             return XMLElementDecl::fgInvalidElemId;
  496.     }
  497.     return decl->getId();
  498. }
  500. inline const XMLElementDecl* SchemaGrammar::getElemDecl( const   unsigned int  uriId
  501.                                               , const XMLCh* const    baseName
  502.                                               , const XMLCh* const
  503.                                               , unsigned int          scope )   const
  504. {
  505.     const SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
  507.     if (!decl) {
  509.         decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
  511.         if (!decl)
  512.             decl = fElemNonDeclPool->getByKey(baseName, uriId, scope);
  513.     }
  515.     return decl;
  516. }
  518. inline XMLElementDecl* SchemaGrammar::getElemDecl (const   unsigned int  uriId
  519.                                               , const XMLCh* const    baseName
  520.                                               , const XMLCh* const
  521.                                               , unsigned int          scope )
  522. {
  523.     SchemaElementDecl* decl = fElemDeclPool->getByKey(baseName, uriId, scope);
  525.     if (!decl) {
  527.         decl = fGroupElemDeclPool->getByKey(baseName, uriId, scope);
  529.         if (!decl)
  530.             decl = fElemNonDeclPool->getByKey(baseName, uriId, scope);
  531.     }
  533.     return decl;
  534. }
  536. inline const XMLElementDecl* SchemaGrammar::getElemDecl(const unsigned int elemId) const
  537. {
  538.     // Look up this element decl by id
  539.     const SchemaElementDecl* decl = fElemDeclPool->getById(elemId);
  541.     if (!decl)
  542.         decl = fGroupElemDeclPool->getById(elemId);
  544.     return decl;
  545. }
  547. inline XMLElementDecl* SchemaGrammar::getElemDecl(const unsigned int elemId)
  548. {
  549.     // Look up this element decl by id
  550.     SchemaElementDecl* decl = fElemDeclPool->getById(elemId);
  552.     if (!decl)
  553.         decl = fGroupElemDeclPool->getById(elemId);
  555.     return decl;
  556. }
  558. inline unsigned int
  559. SchemaGrammar::putElemDecl(XMLElementDecl* const elemDecl,
  560.                            const bool notDeclared) const
  561. {
  562.     if (notDeclared)
  563.         return fElemNonDeclPool->put(elemDecl->getBaseName(), elemDecl->getURI(), ((SchemaElementDecl* )elemDecl)->getEnclosingScope(), (SchemaElementDecl*) elemDecl);
  565.     return fElemDeclPool->put(elemDecl->getBaseName(), elemDecl->getURI(), ((SchemaElementDecl* )elemDecl)->getEnclosingScope(), (SchemaElementDecl*) elemDecl);
  566. }
  568. inline unsigned int SchemaGrammar::putGroupElemDecl (XMLElementDecl* const elemDecl)   const
  569. {
  570.     return fGroupElemDeclPool->put(elemDecl->getBaseName(), elemDecl->getURI(), ((SchemaElementDecl* )elemDecl)->getEnclosingScope(), (SchemaElementDecl*) elemDecl);
  571. }
  573. // Notation Decl
  574. inline const XMLNotationDecl* SchemaGrammar::getNotationDecl(const XMLCh* const notName) const
  575. {
  576.     return fNotationDeclPool->getByKey(notName);
  577. }
  579. inline XMLNotationDecl* SchemaGrammar::getNotationDecl(const XMLCh* const notName)
  580. {
  581.     return fNotationDeclPool->getByKey(notName);
  582. }
  584. inline unsigned int SchemaGrammar::putNotationDecl(XMLNotationDecl* const notationDecl)   const
  585. {
  586.     return fNotationDeclPool->put(notationDecl);
  587. }
  589. inline bool SchemaGrammar::getValidated() const
  590. {
  591.     return fValidated;
  592. }
  594. inline void SchemaGrammar::setValidated(const bool newState)
  595. {
  596.     fValidated = newState;
  597. }
  599. XERCES_CPP_NAMESPACE_END
  601. #endif