/*
* Copyright 1999-2004 The Apache Software Foundation.
*
* Licensed 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 191668 2005-06-21 15:34:32Z cargilld $
*/
#if !defined(XMLGrammarPoolImplIMPL_HPP)
#define XMLGrammarPoolImplIMPL_HPP
#include <xercesc/framework/XMLGrammarPool.hpp>
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<Grammar> 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<Grammar>* fGrammarRegistry;
XMLStringPool* fStringPool;
XMLSynchronizedStringPool* fSynchronizedStringPool;
XSModel* fXSModel;
bool fLocked;
bool fXSModelIsValid;
};
XERCES_CPP_NAMESPACE_END
#endif
Submit an article or tip