| /* |
| * 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: SchemaGrammar.cpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| |
| // --------------------------------------------------------------------------- |
| // Includes |
| // --------------------------------------------------------------------------- |
| #include <xercesc/validators/schema/SchemaGrammar.hpp> |
| #include <xercesc/validators/schema/NamespaceScope.hpp> |
| #include <xercesc/validators/schema/ComplexTypeInfo.hpp> |
| #include <xercesc/validators/schema/SchemaSymbols.hpp> |
| #include <xercesc/validators/schema/XercesGroupInfo.hpp> |
| #include <xercesc/validators/schema/XercesAttGroupInfo.hpp> |
| #include <xercesc/validators/schema/XMLSchemaDescriptionImpl.hpp> |
| #include <xercesc/util/OutOfMemoryException.hpp> |
| #include <xercesc/util/HashPtr.hpp> |
| #include <xercesc/framework/psvi/XSAnnotation.hpp> |
| |
| #include <xercesc/internal/XTemplateSerializer.hpp> |
| #include <xercesc/internal/ValidationContextImpl.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| typedef JanitorMemFunCall<SchemaGrammar> CleanupType; |
| |
| // --------------------------------------------------------------------------- |
| // SchemaGrammar: Constructors and Destructor |
| // --------------------------------------------------------------------------- |
| SchemaGrammar::SchemaGrammar(MemoryManager* const manager) : |
| fTargetNamespace(0) |
| , fElemDeclPool(0) |
| , fElemNonDeclPool(0) |
| , fGroupElemDeclPool(0) |
| , fNotationDeclPool(0) |
| , fAttributeDeclRegistry(0) |
| , fComplexTypeRegistry(0) |
| , fGroupInfoRegistry(0) |
| , fAttGroupInfoRegistry(0) |
| , fNamespaceScope(0) |
| , fValidSubstitutionGroups(0) |
| , fValidationContext(0) |
| , fMemoryManager(manager) |
| , fGramDesc(0) |
| , fAnnotations(0) |
| , fValidated(false) |
| , fDatatypeRegistry(manager) |
| { |
| CleanupType cleanup(this, &SchemaGrammar::cleanUp); |
| |
| // |
| // Init all the pool members. |
| // |
| // <TBD> Investigate what the optimum values would be for the various |
| // pools. |
| // |
| fElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109, true, 128, fMemoryManager); |
| |
| try { |
| // should not be necessary now that grammars, once built, |
| // are read-only |
| // fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager); |
| fGroupElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109, false, 128, fMemoryManager); |
| fNotationDeclPool = new (fMemoryManager) NameIdPool<XMLNotationDecl>(109, 128, fMemoryManager); |
| fValidationContext = new (fMemoryManager) ValidationContextImpl(fMemoryManager); |
| fDatatypeRegistry.expandRegistryToFullSchemaSet(); |
| |
| //REVISIT: use grammarPool to create |
| fGramDesc = new (fMemoryManager) XMLSchemaDescriptionImpl(XMLUni::fgXMLNSURIName, fMemoryManager); |
| |
| // Create annotation table |
| fAnnotations = new (fMemoryManager) RefHashTableOf<XSAnnotation> |
| ( |
| 29, true, new (fMemoryManager) HashPtr(), fMemoryManager |
| ); |
| |
| // |
| // Call our own reset method. This lets us have the pool setup stuff |
| // done in just one place (because this stame setup stuff has to be |
| // done every time we are reset.) |
| // |
| reset(); |
| } |
| catch(const OutOfMemoryException&) |
| { |
| cleanup.release(); |
| |
| throw; |
| } |
| |
| cleanup.release(); |
| } |
| |
| SchemaGrammar::~SchemaGrammar() |
| { |
| cleanUp(); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Virtual methods |
| // ----------------------------------------------------------------------- |
| XMLElementDecl* SchemaGrammar::findOrAddElemDecl (const unsigned int uriId |
| , const XMLCh* const baseName |
| , const XMLCh* const prefixName |
| , const XMLCh* const qName |
| , unsigned int scope |
| , bool& wasAdded ) |
| { |
| // See it it exists |
| SchemaElementDecl* retVal = (SchemaElementDecl*) getElemDecl(uriId, baseName, qName, scope); |
| |
| // if not, then add this in |
| if (!retVal) |
| { |
| retVal = new (fMemoryManager) SchemaElementDecl |
| ( |
| prefixName |
| , baseName |
| , uriId |
| , SchemaElementDecl::Any |
| , Grammar::TOP_LEVEL_SCOPE |
| , fMemoryManager |
| ); |
| if(!fElemNonDeclPool) |
| fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager); |
| const unsigned int elemId = fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal); |
| retVal->setId(elemId); |
| wasAdded = true; |
| } |
| else |
| { |
| wasAdded = false; |
| } |
| return retVal; |
| } |
| |
| XMLElementDecl* SchemaGrammar::putElemDecl (const unsigned int uriId |
| , const XMLCh* const baseName |
| , const XMLCh* const prefixName |
| , const XMLCh* const |
| , unsigned int scope |
| , const bool notDeclared) |
| { |
| SchemaElementDecl* retVal = new (fMemoryManager) SchemaElementDecl |
| ( |
| prefixName |
| , baseName |
| , uriId |
| , SchemaElementDecl::Any |
| , Grammar::TOP_LEVEL_SCOPE |
| , fMemoryManager |
| ); |
| if(notDeclared) |
| { |
| if(!fElemNonDeclPool) |
| fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager); |
| retVal->setId(fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal)); |
| } else |
| { |
| retVal->setId(fElemDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal)); |
| } |
| return retVal; |
| } |
| |
| void SchemaGrammar::reset() |
| { |
| // |
| // We need to reset all of the pools. |
| // |
| fElemDeclPool->removeAll(); |
| if(fElemNonDeclPool) |
| fElemNonDeclPool->removeAll(); |
| fGroupElemDeclPool->removeAll(); |
| fNotationDeclPool->removeAll(); |
| fAnnotations->removeAll(); |
| fValidated = false; |
| } |
| |
| |
| void SchemaGrammar::cleanUp() |
| { |
| |
| delete fElemDeclPool; |
| if(fElemNonDeclPool) |
| delete fElemNonDeclPool; |
| delete fGroupElemDeclPool; |
| delete fNotationDeclPool; |
| fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace; |
| delete fAttributeDeclRegistry; |
| delete fComplexTypeRegistry; |
| delete fGroupInfoRegistry; |
| delete fAttGroupInfoRegistry; |
| delete fNamespaceScope; |
| delete fValidSubstitutionGroups; |
| delete fValidationContext; |
| delete fGramDesc; |
| delete fAnnotations; |
| } |
| |
| void SchemaGrammar::setGrammarDescription(XMLGrammarDescription* gramDesc) |
| { |
| if ((!gramDesc) || |
| (gramDesc->getGrammarType() != Grammar::SchemaGrammarType)) |
| return; |
| |
| if (fGramDesc) |
| delete fGramDesc; |
| |
| //adopt the grammar Description |
| fGramDesc = (XMLSchemaDescription*) gramDesc; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SchemaGrammar: Helper methods |
| // --------------------------------------------------------------------------- |
| void SchemaGrammar::putAnnotation(void* key, XSAnnotation* const annotation) |
| { |
| fAnnotations->put(key, annotation); |
| } |
| |
| void SchemaGrammar::addAnnotation(XSAnnotation* const annotation) |
| { |
| XSAnnotation* lAnnot = fAnnotations->get(this); |
| |
| if (lAnnot) |
| lAnnot->setNext(annotation); |
| else |
| fAnnotations->put(this, annotation); |
| } |
| |
| /*** |
| * Support for Serialization/De-serialization |
| ***/ |
| |
| IMPL_XSERIALIZABLE_TOCREATE(SchemaGrammar) |
| |
| void SchemaGrammar::serialize(XSerializeEngine& serEng) |
| { |
| |
| /*** |
| * don't serialize NamespaceScope* fNamespaceScope; |
| * ValidationContext* fValidationContext; |
| * fElemNonDeclPool |
| ***/ |
| |
| Grammar::serialize(serEng); |
| |
| if (serEng.isStoring()) |
| { |
| //serialize DatatypeValidatorFactory first |
| fDatatypeRegistry.serialize(serEng); |
| |
| /*** |
| * |
| * Serialize RefHash3KeysIdPool<SchemaElementDecl>* fElemDeclPool; |
| * Serialize RefHash3KeysIdPool<SchemaElementDecl>* fGroupElemDeclPool; |
| * |
| ***/ |
| XTemplateSerializer::storeObject(fElemDeclPool, serEng); |
| XTemplateSerializer::storeObject(fGroupElemDeclPool, serEng); |
| |
| /*** |
| * Serialize NameIdPool<XMLNotationDecl>* fNotationDeclPool; |
| ***/ |
| XTemplateSerializer::storeObject(fNotationDeclPool, serEng); |
| |
| /*** |
| * |
| * Serialize RefHashTableOf<XMLAttDef>* fAttributeDeclRegistry; |
| * Serialize RefHashTableOf<ComplexTypeInfo>* fComplexTypeRegistry; |
| * Serialize RefHashTableOf<XercesGroupInfo>* fGroupInfoRegistry; |
| * Serialize RefHashTableOf<XercesAttGroupInfo>* fAttGroupInfoRegistry; |
| * Serialize RefHashTableOf<XMLRefInfo>* fIDRefList; |
| * |
| ***/ |
| |
| XTemplateSerializer::storeObject(fAttributeDeclRegistry, serEng); |
| XTemplateSerializer::storeObject(fComplexTypeRegistry, serEng); |
| XTemplateSerializer::storeObject(fGroupInfoRegistry, serEng); |
| XTemplateSerializer::storeObject(fAttGroupInfoRegistry, serEng); |
| |
| /*** |
| * Serialize RefHash2KeysTableOf<ElemVector>* fValidSubstitutionGroups; |
| ***/ |
| XTemplateSerializer::storeObject(fValidSubstitutionGroups, serEng); |
| |
| /*** |
| * Serialize RefHashTableOf<XSAnnotation>* fAnnotations; |
| ***/ |
| XTemplateSerializer::storeObject(fAnnotations, serEng); |
| |
| serEng.writeString(fTargetNamespace); |
| serEng<<fValidated; |
| |
| /*** |
| * serialize() method shall be used to store object |
| * which has been created in ctor |
| ***/ |
| fGramDesc->serialize(serEng); |
| |
| } |
| else |
| { |
| fDatatypeRegistry.serialize(serEng); |
| |
| /*** |
| * |
| * Deserialize RefHash3KeysIdPool<SchemaElementDecl>* fElemDeclPool; |
| * Deserialize RefHash3KeysIdPool<SchemaElementDecl>* fGroupElemDeclPool; |
| * |
| ***/ |
| XTemplateSerializer::loadObject(&fElemDeclPool, 109, true, 128, serEng); |
| XTemplateSerializer::loadObject(&fGroupElemDeclPool, 109, true, 128, serEng); |
| |
| /*** |
| * Deserialize NameIdPool<XMLNotationDecl>* fNotationDeclPool; |
| ***/ |
| XTemplateSerializer::loadObject(&fNotationDeclPool, 109, 128, serEng); |
| |
| /*** |
| * |
| * Deserialize RefHashTableOf<XMLAttDef>* fAttributeDeclRegistry; |
| * Deserialize RefHashTableOf<ComplexTypeInfo>* fComplexTypeRegistry; |
| * Deserialize RefHashTableOf<XercesGroupInfo>* fGroupInfoRegistry; |
| * Deserialize RefHashTableOf<XercesAttGroupInfo>* fAttGroupInfoRegistry; |
| * Deserialize RefHashTableOf<XMLRefInfo>* fIDRefList; |
| * |
| ***/ |
| |
| XTemplateSerializer::loadObject(&fAttributeDeclRegistry, 29, true, serEng); |
| XTemplateSerializer::loadObject(&fComplexTypeRegistry, 29, true, serEng); |
| XTemplateSerializer::loadObject(&fGroupInfoRegistry, 13, true, serEng); |
| XTemplateSerializer::loadObject(&fAttGroupInfoRegistry, 13, true, serEng); |
| |
| /*** |
| * Deserialize RefHash2KeysTableOf<ElemVector>* fValidSubstitutionGroups; |
| ***/ |
| XTemplateSerializer::loadObject(&fValidSubstitutionGroups, 29, true, serEng); |
| |
| /*** |
| * Deserialize RefHashTableOf<XSAnnotation>* fAnnotations; |
| ***/ |
| XTemplateSerializer::loadObject(&fAnnotations, 29, true, serEng); |
| |
| serEng.readString(fTargetNamespace); |
| serEng>>fValidated; |
| |
| /*** |
| * serialize() method shall be used to load object |
| * which has been created in ctor |
| ***/ |
| fGramDesc->serialize(serEng); |
| |
| } |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
