void GrammarResolver::cacheGrammars()
{
RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarBucket, false, fMemoryManager);
ValueVectorOf<XMLCh*> keys(8, fMemoryManager);
unsigned int keyCount = 0;
// Build key set
while (grammarEnum.hasMoreElements())
{
XMLCh* grammarKey = (XMLCh*) grammarEnum.nextElementKey();
keys.addElement(grammarKey);
keyCount++;
}
// PSVI: assume everything will be added, if caching fails add grammar back
// into vector
fGrammarsToAddToXSModel->removeAllElements();
// Cache
for (unsigned int i = 0; i < keyCount; i++)
{
XMLCh* grammarKey = keys.elementAt(i);
/***
* It is up to the GrammarPool implementation to handle duplicated grammar
*/
Grammar* grammar = fGrammarBucket->get(grammarKey);
if(fGrammarPool->cacheGrammar(grammar))
{
// only orphan grammar if grammar pool accepts caching of it
fGrammarBucket->orphanKey(grammarKey);
}
else if (grammar->getGrammarType() == Grammar::SchemaGrammarType)
{
// add it back to list of grammars not in grammar pool
fGrammarsToAddToXSModel->addElement((SchemaGrammar*) grammar);
}
}
}
/***
* .non-empty gramamrRegistry
***/
void XMLGrammarPoolImpl::serializeGrammars(BinOutputStream* const binOut)
{
RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarRegistry, false, getMemoryManager());
if (!(grammarEnum.hasMoreElements()))
{
ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_GrammarPool_Empty, getMemoryManager());
}
XSerializeEngine serEng(binOut, this);
//version information
serEng<<(unsigned int)XERCES_GRAMMAR_SERIALIZATION_LEVEL;
//lock status
serEng<<fLocked;
//StringPool, don't use <<
fStringPool->serialize(serEng);
/***
* Serialize RefHashTableOf<Grammar>* fGrammarRegistry;
***/
XTemplateSerializer::storeObject(fGrammarRegistry, serEng);
}
XSModel *GrammarResolver::getXSModel()
{
XSModel* xsModel;
if (fCacheGrammar || fUseCachedGrammar)
{
// We know if the grammarpool changed thru caching, orphaning and erasing
// but NOT by other mechanisms such as lockPool() or unlockPool() so it
// is safest to always get it. The grammarPool XSModel will only be
// regenerated if something changed.
bool XSModelWasChanged;
// The grammarpool will always return an xsmodel, even if it is just
// the schema for schema xsmodel...
xsModel = fGrammarPool->getXSModel(XSModelWasChanged);
if (XSModelWasChanged)
{
// we know the grammarpool XSModel has changed or this is the
// first call to getXSModel
if (!fGrammarPoolXSModel && (fGrammarsToAddToXSModel->size() == 0) &&
!fXSModel)
{
fGrammarPoolXSModel = xsModel;
return fGrammarPoolXSModel;
}
else
{
fGrammarPoolXSModel = xsModel;
// We had previously augmented the grammar pool XSModel
// with our our grammars or we would like to upate it now
// so we have to regenerate the XSModel
fGrammarsToAddToXSModel->removeAllElements();
RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarBucket, false, fMemoryManager);
while (grammarEnum.hasMoreElements())
{
Grammar& grammar = (Grammar&) grammarEnum.nextElement();
if (grammar.getGrammarType() == Grammar::SchemaGrammarType)
fGrammarsToAddToXSModel->addElement((SchemaGrammar*)&grammar);
}
delete fXSModel;
if (fGrammarsToAddToXSModel->size())
{
fXSModel = new (fMemoryManager) XSModel(fGrammarPoolXSModel, this, fMemoryManager);
fGrammarsToAddToXSModel->removeAllElements();
return fXSModel;
}
fXSModel = 0;
return fGrammarPoolXSModel;
}
}
else {
// we know that the grammar pool XSModel is the same as before
if (fGrammarsToAddToXSModel->size())
{
// we need to update our fXSModel with the new grammars
if (fXSModel)
{
xsModel = new (fMemoryManager) XSModel(fXSModel, this, fMemoryManager);
fXSModel = xsModel;
}
else
{
fXSModel = new (fMemoryManager) XSModel(fGrammarPoolXSModel, this, fMemoryManager);
}
fGrammarsToAddToXSModel->removeAllElements();
return fXSModel;
}
// Nothing has changed!
if (fXSModel)
{
return fXSModel;
}
else if (fGrammarPoolXSModel)
{
return fGrammarPoolXSModel;
}
fXSModel = new (fMemoryManager) XSModel(0, this, fMemoryManager);
return fXSModel;
}
}
// Not Caching...
if (fGrammarsToAddToXSModel->size())
{
xsModel = new (fMemoryManager) XSModel(fXSModel, this, fMemoryManager);
fGrammarsToAddToXSModel->removeAllElements();
fXSModel = xsModel;
}
else if (!fXSModel)
{
// create a new model only if we didn't have one already
fXSModel = new (fMemoryManager) XSModel(0, this, fMemoryManager);
}
return fXSModel;
}
/***
* .empty stringPool
* .empty gramamrRegistry
***/
void XMLGrammarPoolImpl::deserializeGrammars(BinInputStream* const binIn)
{
MemoryManager *memMgr = getMemoryManager();
unsigned int stringCount = fStringPool->getStringCount();
if (stringCount)
{
/***
* it contains only the four predefined one, that is ok
* but we need to reset the string before deserialize it
*
***/
if ( stringCount <= 4 )
{
fStringPool->flushAll();
}
else
{
ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_StringPool_NotEmpty, memMgr);
}
}
RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarRegistry, false, memMgr);
if (grammarEnum.hasMoreElements())
{
ThrowXMLwithMemMgr(XSerializationException, XMLExcepts::XSer_GrammarPool_NotEmpty, memMgr);
}
// This object will take care of cleaning up if an exception is
// thrown during deserialization.
JanitorMemFunCall<XMLGrammarPoolImpl> cleanup(this, &XMLGrammarPoolImpl::cleanUp);
try
{
XSerializeEngine serEng(binIn, this);
//version information
unsigned int StorerLevel;
serEng>>StorerLevel;
serEng.fStorerLevel = StorerLevel;
// The storer level must match the loader level.
//
if (StorerLevel != (unsigned int)XERCES_GRAMMAR_SERIALIZATION_LEVEL)
{
XMLCh StorerLevelChar[5];
XMLCh LoaderLevelChar[5];
XMLString::binToText(StorerLevel, StorerLevelChar, 4, 10, memMgr);
XMLString::binToText(XERCES_GRAMMAR_SERIALIZATION_LEVEL, LoaderLevelChar, 4, 10, memMgr);
ThrowXMLwithMemMgr2(XSerializationException
, XMLExcepts::XSer_Storer_Loader_Mismatch
, StorerLevelChar
, LoaderLevelChar
, memMgr);
}
//lock status
serEng>>fLocked;
//StringPool, don't use >>
fStringPool->serialize(serEng);
/***
* Deserialize RefHashTableOf<Grammar>* fGrammarRegistry;
***/
XTemplateSerializer::loadObject(&fGrammarRegistry, 29, true, serEng);
}
catch(const OutOfMemoryException&)
{
// This is a special case, because we don't want
// to execute cleanup code on out-of-memory
// conditions.
cleanup.release();
throw;
}
// Everything is OK, so we can release the cleanup object.
cleanup.release();
if (fLocked)
{
createXSModel();
}
}