secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLGrammarPoolImpl.hpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLGrammarPoolImpl.hpp Thu May 27 12:58:35 2010 +0300
@@ -0,0 +1,303 @@
+/*
+ * 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 <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