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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  *
  5.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  6.  * reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  *
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in
  17.  *    the documentation and/or other materials provided with the
  18.  *    distribution.
  19.  *
  20.  * 3. The end-user documentation included with the redistribution,
  21.  *    if any, must include the following acknowledgment:
  22.  *       "This product includes software developed by the
  23.  *        Apache Software Foundation (http://www.apache.org/)."
  24.  *    Alternately, this acknowledgment may appear in the software itself,
  25.  *    if and wherever such third-party acknowledgments normally appear.
  26.  *
  27.  * 4. The names "Xerces" and "Apache Software Foundation" must
  28.  *    not be used to endorse or promote products derived from this
  29.  *    software without prior written permission. For written
  30.  *    permission, please contact apache@apache.org.
  31.  *
  32.  * 5. Products derived from this software may not be called "Apache",
  33.  *    nor may "Apache" appear in their name, without prior written
  34.  *    permission of the Apache Software Foundation.
  35.  *
  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  47.  * SUCH DAMAGE.
  48.  * ====================================================================
  49.  *
  50.  * This software consists of voluntary contributions made by many
  51.  * individuals on behalf of the Apache Software Foundation and was
  52.  * originally based on software copyright (c) 2001, International
  53.  * Business Machines, Inc., http://www.apache.org.  For more
  54.  * information on the Apache Software Foundation, please see
  55.  * <http://www.apache.org/>.
  56.  */
  57. /**
  58.  * $Id: GrammarResolver.hpp,v 1.6 2003/05/16 21:43:20 knoaman Exp $
  59.  */
  60. #if !defined(GRAMMARRESOLVER_HPP)
  61. #define GRAMMARRESOLVER_HPP
  62. #include <xercesc/util/RefHashTableOf.hpp>
  63. #include <xercesc/util/StringPool.hpp>
  64. #include <xercesc/validators/common/Grammar.hpp>
  65. XERCES_CPP_NAMESPACE_BEGIN
  66. class DatatypeValidator;
  67. class DatatypeValidatorFactory;
  68. /**
  69.  * This class embodies the representation of a Grammar pool Resolver.
  70.  * This class is called from the validator.
  71.  *
  72.  */
  73. class VALIDATORS_EXPORT GrammarResolver : public XMemory
  74. {
  75. public:
  76.     /** @name Constructor and Destructor */
  77.     //@{
  78.     /**
  79.      *
  80.      * Default Constructor
  81.      */
  82.     GrammarResolver(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
  83.     /**
  84.       * Destructor
  85.       */
  86.     ~GrammarResolver();
  87.     //@}
  88.     /** @name Getter methods */
  89.     //@{
  90.     /**
  91.      * Retrieve the DatatypeValidator
  92.      *
  93.      * @param uriStr the namespace URI
  94.      * @param typeName the type name
  95.      * @return the DatatypeValidator associated with namespace & type name
  96.      */
  97.     DatatypeValidator* getDatatypeValidator(const XMLCh* const uriStr,
  98.                                             const XMLCh* const typeName);
  99.     /**
  100.      * Retrieve the grammar that is associated with the specified namespace key
  101.      *
  102.      * @param  nameSpaceKey   Namespace key into Grammar pool
  103.      * @return Grammar abstraction associated with the NameSpace key.
  104.      */
  105.     Grammar* getGrammar( const XMLCh* const nameSpaceKey ) ;
  106.     /**
  107.      * Get an enumeration of Grammar in the Grammar pool
  108.      *
  109.      * @return enumeration of Grammar in Grammar pool
  110.      */
  111.     RefHashTableOfEnumerator<Grammar> getGrammarEnumerator() const;
  112.     /**
  113.      * Get a string pool of schema grammar element/attribute names/prefixes
  114.      * (used by TraverseSchema)
  115.      *
  116.      * @return a string pool of schema grammar element/attribute names/prefixes
  117.      */
  118.     XMLStringPool* getStringPool();
  119.     /**
  120.      * Is the specified Namespace key in Grammar pool?
  121.      *
  122.      * @param  nameSpaceKey    Namespace key
  123.      * @return True if Namespace key association is in the Grammar pool.
  124.      */
  125.     bool containsNameSpace( const XMLCh* const nameSpaceKey );
  126.     //@}
  127.     /** @name Setter methods */
  128.     //@{
  129.     /**
  130.       * Set the 'Grammar caching' flag
  131.       */
  132.     void cacheGrammarFromParse(const bool newState);
  133.     /**
  134.       * Set the 'Use cached grammar' flag
  135.       */
  136.     void useCachedGrammarInParse(const bool newState);
  137.     //@}
  138.     /** @name GrammarResolver methods */
  139.     //@{
  140.     /**
  141.      * Add the Grammar with Namespace Key associated to the Grammar Pool.
  142.      * The Grammar will be owned by the Grammar Pool.
  143.      *
  144.      * @param  nameSpaceKey    Key to associate with Grammar abstraction
  145.      * @param  grammarToAdopt  Grammar abstraction used by validator.
  146.      */
  147.     void putGrammar(const XMLCh* const nameSpaceKey, Grammar* const grammarToAdopt );
  148.     /**
  149.      * Returns the Grammar with Namespace Key associated from the Grammar Pool
  150.      * The Key entry is removed from the table (grammar is not deleted if
  151.      * adopted - now owned by caller).
  152.      *
  153.      * @param  nameSpaceKey    Key to associate with Grammar abstraction
  154.      */
  155.     Grammar* orphanGrammar(const XMLCh* const nameSpaceKey);
  156.     /**
  157.      * Cache the grammars in fGrammarRegistry to fCachedGrammarRegistry.
  158.      * If a grammar with the same key is already cached, an exception is
  159.      * thrown and none of the grammars will be cached.
  160.      */
  161.     void cacheGrammars();
  162.     /**
  163.      * Reset internal Namespace/Grammar registry.
  164.      */
  165.     void reset();
  166.     void resetCachedGrammar();
  167.     //@}
  168. private:
  169.     // -----------------------------------------------------------------------
  170.     //  Private data members
  171.     //
  172.     //  fStringPool            The string pool used by TraverseSchema to store
  173.     //                         element/attribute names and prefixes.
  174.     //
  175.     //  fGrammarRegistry       The parsed Grammar Pool, if no caching option.
  176.     //
  177.     //  fCachedGrammarRegistry The cached Grammar Pool.  It represents a
  178.     //                         mapping between Namespace and a Grammar
  179.     //
  180.     //  fDataTypeReg           DatatypeValidatorFactory registery
  181.     //
  182.     //  fMemoryManager         Pluggable memory manager for dynamic memory
  183.     //                         allocation/deallocation
  184.     // -----------------------------------------------------------------------
  185.     bool                       fCacheGrammar;
  186.     bool                       fUseCachedGrammar;
  187.     XMLStringPool              fStringPool;
  188.     RefHashTableOf<Grammar>*   fGrammarRegistry;
  189.     RefHashTableOf<Grammar>*   fCachedGrammarRegistry;
  190.     DatatypeValidatorFactory*  fDataTypeReg;
  191.     MemoryManager*             fMemoryManager;
  192. };
  193. inline XMLStringPool* GrammarResolver::getStringPool() {
  194.     return &fStringPool;
  195. }
  196. inline void GrammarResolver::useCachedGrammarInParse(const bool aValue)
  197. {
  198.     fUseCachedGrammar = aValue;
  199. }
  200. inline Grammar*
  201. GrammarResolver::orphanGrammar(const XMLCh* const nameSpaceKey) {
  202.     if (fCacheGrammar)
  203.         return fCachedGrammarRegistry->orphanKey(nameSpaceKey);
  204.     return fGrammarRegistry->orphanKey(nameSpaceKey);
  205. }
  206. XERCES_CPP_NAMESPACE_END
  207. #endif