/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: XMLGrammarPoolImpl.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(XMLGrammarPoolImplIMPL_HPP) #define XMLGrammarPoolImplIMPL_HPP #include XERCES_CPP_NAMESPACE_BEGIN class XMLSynchronizedStringPool; class XMLUTIL_EXPORT XMLGrammarPoolImpl : public XMLGrammarPool { public : // ----------------------------------------------------------------------- /** @name constructor and destructor */ // ----------------------------------------------------------------------- //@{ XMLGrammarPoolImpl(MemoryManager* const memMgr); ~XMLGrammarPoolImpl(); //@} // ----------------------------------------------------------------------- /** @name Implementation of Grammar Pool Interface */ // ----------------------------------------------------------------------- //@{ /** * cacheGrammar * * Provide the grammar pool with an opportunity * to cache the given grammar. If the pool does not choose to do so, * it should return false; otherwise, it should return true, so that * the caller knows whether the grammar has been adopted. * * @param gramToCache: the Grammar to be cached in the grammar pool * @return true if the grammar pool has elected to cache the grammar (in which case * it is assumed to have adopted it); false if it does not cache it * */ virtual bool cacheGrammar(Grammar* const gramToCache); /** * retrieveGrammar * * @param gramDesc: the Grammar Description used to search for grammar * cached in the grammar pool * */ virtual Grammar* retrieveGrammar(XMLGrammarDescription* const gramDesc); /** * orphanGrammar * * grammar removed from the grammar pool and owned by the caller * * @param nameSpaceKey: Key used to search for grammar in the grammar pool * */ virtual Grammar* orphanGrammar(const XMLCh* const nameSpaceKey); /** * Get an enumeration of the cached Grammars in the Grammar pool * * @return enumeration of the cached Grammars in Grammar pool */ virtual RefHashTableOfEnumerator getGrammarEnumerator() const; /** * clear * * all grammars are removed from the grammar pool and deleted. * @return true if the grammar pool was cleared. false if it did not. */ virtual bool clear(); /** * lockPool * * When this method is called by the application, the * grammar pool should stop adding new grammars to the cache. */ virtual void lockPool(); /** * unlockPool * * After this method has been called, the grammar pool implementation * should return to its default behaviour when cacheGrammars(...) is called. * * For PSVI support any previous XSModel that was produced will be deleted. */ virtual void unlockPool(); //@} // ----------------------------------------------------------------------- /** @name Implementation of Factory interface */ // ----------------------------------------------------------------------- //@{ /** * createDTDGrammar * */ virtual DTDGrammar* createDTDGrammar(); /** * createSchemaGrammar * */ virtual SchemaGrammar* createSchemaGrammar(); /** * createDTDDescription * */ virtual XMLDTDDescription* createDTDDescription(const XMLCh* const systemId); /** * createSchemaDescription * */ virtual XMLSchemaDescription* createSchemaDescription(const XMLCh* const targetNamespace); //@} // ----------------------------------------------------------------------- /** @name schema component model support */ // ----------------------------------------------------------------------- //@{ /*** * Return an XSModel derived from the components of all SchemaGrammars * in the grammar pool. If the pool is locked, this should * be a thread-safe operation. It should return null if and only if * the pool is empty. * * Calling getXSModel() on an unlocked grammar pool may result in the * creation of a new XSModel with the old XSModel being deleted. The * function will return a different address for the XSModel if it has * changed. * * In this implementation, when the pool is not locked a new XSModel will be * computed each this time the pool is called if the pool has changed (and the * previous one will be destroyed at that time). When the lockPool() * method is called, an XSModel will be generated and returned whenever this method is called * while the pool is in the locked state. This will be destroyed if the unlockPool() * operation is called. The XSModel will not be serialized, * but will be recreated if a deserialized pool is in the * locked state. * * @deprecated (shouldn't use address to determine if XSModel changed) */ virtual XSModel *getXSModel(); /*** * Return an XSModel derived from the components of all SchemaGrammars * in the grammar pool. If the pool is locked, this should * be a thread-safe operation. * * NOTE: The function should NEVER return NULL. If there are no grammars in * the pool it should return an XSModel containing the Schema for Schema. * * Calling getXSModel() on an unlocked grammar pool may result in the * creation of a new XSModel with the old XSModel being deleted. * The bool parameter will indicate if the XSModel was changed. * * In this implementation, when the pool is not locked a new XSModel will be * computed each this time the pool is called if the pool has changed (and the * previous one will be destroyed at that time). When the lockPool() * method is called, an XSModel will be generated and returned whenever this method is called * while the pool is in the locked state. This will be destroyed if the unlockPool() * operation is called. The XSModel will not be serialized, * but will be recreated if a deserialized pool is in the * locked state. * */ virtual XSModel *getXSModel(bool& XSModelWasChanged); // @} // ----------------------------------------------------------------------- /** @name Getter */ // ----------------------------------------------------------------------- //@{ /** * Return an XMLStringPool for use by validation routines. * Implementations should not create a string pool on each call to this * method, but should maintain one string pool for all grammars * for which this pool is responsible. */ virtual XMLStringPool *getURIStringPool(); // @} // ----------------------------------------------------------------------- // serialization and deserialization support // ----------------------------------------------------------------------- /*** * * Multiple serializations * * For multiple serializations, if the same file name is given, then the * last result will be in the file (overwriting mode), if different file * names are given, then there are multiple data stores for each serialization. * * Multiple deserializations * * Not supported * * Versioning * * Only binary data serialized with the current XercesC Version and * SerializationLevel is supported. * * Clean up * * In the event of an exception thrown due to a corrupted data store during * deserialization, this implementation may not be able to clean up all resources * allocated, and therefore it is the client application's responsibility to * clean up those unreleased resources. * * Coupling of Grammars and StringPool * * This implementation assumes that StringPool shall always be * serialized/deserialized together with the grammars. In the case that such a * coupling is not desired, client application can modify this behaviour by * either derivate from this imlementation and overwrite the serializeGrammars() * and/or deserializeGrammars() to decouple grammars and string pool, or * Once deserializeGrammars() is done, insert another StringPool through * setStringPool(). * * Client application shall be aware of the unpredicatable/undefined consequence * of this decoupling. */ virtual void serializeGrammars(BinOutputStream* const); virtual void deserializeGrammars(BinInputStream* const); private: virtual void createXSModel(); void cleanUp(); // ----------------------------------------------------------------------- /** name Unimplemented copy constructor and operator= */ // ----------------------------------------------------------------------- //@{ XMLGrammarPoolImpl(const XMLGrammarPoolImpl& ); XMLGrammarPoolImpl& operator=(const XMLGrammarPoolImpl& ); //@} // ----------------------------------------------------------------------- // // fGrammarRegistry: // // container // fStringPool // grammars need a string pool for URI -> int mappings // fSynchronizedStringPool // When the grammar pool is locked, provide a string pool // that can be updated in a thread-safe manner. // fLocked // whether the pool has been locked // // ----------------------------------------------------------------------- RefHashTableOf* fGrammarRegistry; XMLStringPool* fStringPool; XMLSynchronizedStringPool* fSynchronizedStringPool; XSModel* fXSModel; bool fLocked; bool fXSModelIsValid; }; XERCES_CPP_NAMESPACE_END #endif