| /* |
| * 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: SchemaInfo.hpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| #if !defined(SCHEMAINFO_HPP) |
| #define SCHEMAINFO_HPP |
| |
| |
| /** When in a <redefine>, type definitions being used (and indeed |
| * refs to <group>'s and <attributeGroup>'s) may refer to info |
| * items either in the schema being redefined, in the <redefine>, |
| * or else in the schema doing the redefining. Because of this |
| * latter we have to be prepared sometimes to look for our type |
| * definitions outside the schema stored in fSchemaRootElement. |
| * This simple class does this; it's just a linked list that |
| * lets us look at the <schema>'s on the queue; note also that this |
| * should provide us with a mechanism to handle nested <redefine>'s. |
| * It's also a handy way of saving schema info when importing/including. |
| */ |
| |
| // --------------------------------------------------------------------------- |
| // Includes |
| // --------------------------------------------------------------------------- |
| #include <xercesc/dom/DOMElement.hpp> |
| #include <xercesc/util/RefVectorOf.hpp> |
| #include <xercesc/util/ValueVectorOf.hpp> |
| #include <xercesc/util/RefHashTableOf.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| // --------------------------------------------------------------------------- |
| // Forward Declarations |
| // --------------------------------------------------------------------------- |
| class ValidationContext; |
| |
| |
| class VALIDATORS_EXPORT SchemaInfo : public XMemory |
| { |
| public: |
| |
| enum ListType { |
| // Redefine is treated as an include |
| IMPORT = 1, |
| INCLUDE = 2 |
| }; |
| |
| enum { |
| C_ComplexType, |
| C_SimpleType, |
| C_Group, |
| C_Attribute, |
| C_AttributeGroup, |
| C_Element, |
| C_Notation, |
| |
| C_Count |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // Constructor/Destructor |
| // ----------------------------------------------------------------------- |
| SchemaInfo(const unsigned short fElemAttrDefaultQualified, |
| const int blockDefault, |
| const int finalDefault, |
| const int targetNSURI, |
| const int scopeCount, |
| const unsigned int namespaceScopeLevel, |
| XMLCh* const schemaURL, |
| const XMLCh* const targetNSURIString, |
| const DOMElement* const root, |
| MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); |
| ~SchemaInfo(); |
| |
| |
| // ----------------------------------------------------------------------- |
| // Getter methods |
| // ----------------------------------------------------------------------- |
| XMLCh* getCurrentSchemaURL() const; |
| const XMLCh* const getTargetNSURIString() const; |
| const DOMElement* getRoot() const; |
| bool getProcessed() const; |
| int getBlockDefault() const; |
| int getFinalDefault() const; |
| int getTargetNSURI() const; |
| int getScopeCount() const; |
| unsigned int getNamespaceScopeLevel() const; |
| unsigned short getElemAttrDefaultQualified() const; |
| BaseRefVectorEnumerator<SchemaInfo> getImportingListEnumerator() const; |
| ValueVectorOf<const DOMElement*>* getRecursingAnonTypes() const; |
| ValueVectorOf<const XMLCh*>* getRecursingTypeNames() const; |
| ValueVectorOf<DOMNode*>* getNonXSAttList() const; |
| ValidationContext* getValidationContext() const; |
| |
| // ----------------------------------------------------------------------- |
| // Setter methods |
| // ----------------------------------------------------------------------- |
| void setProcessed(const bool aValue = true); |
| void setScopeCount(const int aValue); |
| void setBlockDefault(const int aValue); |
| void setFinalDefault(const int aValue); |
| void setElemAttrDefaultQualified(const unsigned short aValue); |
| |
| // ----------------------------------------------------------------------- |
| // Access methods |
| // ----------------------------------------------------------------------- |
| void addSchemaInfo(SchemaInfo* const toAdd, const ListType aListType); |
| bool containsInfo(const SchemaInfo* const toCheck, const ListType aListType) const; |
| SchemaInfo* getImportInfo(const unsigned int namespaceURI) const; |
| DOMElement* getTopLevelComponent(const unsigned short compCategory, |
| const XMLCh* const compName, |
| const XMLCh* const name); |
| DOMElement* getTopLevelComponent(const unsigned short compCategory, |
| const XMLCh* const compName, |
| const XMLCh* const name, |
| SchemaInfo** enclosingSchema); |
| void updateImportingInfo(SchemaInfo* const importingInfo); |
| bool circularImportExist(const unsigned int nameSpaceURI); |
| bool isFailedRedefine(const DOMElement* const anElem); |
| void addFailedRedefine(const DOMElement* const anElem); |
| bool isImportingNS(const int namespaceURI); |
| void addImportedNS(const int namespaceURI); |
| void addRecursingType(const DOMElement* const elem, const XMLCh* const name); |
| |
| private: |
| // ----------------------------------------------------------------------- |
| // Unimplemented constructors and operators |
| // ----------------------------------------------------------------------- |
| SchemaInfo(const SchemaInfo&); |
| SchemaInfo& operator=(const SchemaInfo&); |
| |
| // ----------------------------------------------------------------------- |
| // Private helper methods |
| // ----------------------------------------------------------------------- |
| void clearTopLevelComponents(); |
| |
| // ----------------------------------------------------------------------- |
| // Private data members |
| // ----------------------------------------------------------------------- |
| bool fAdoptInclude; |
| bool fProcessed; |
| unsigned short fElemAttrDefaultQualified; |
| int fBlockDefault; |
| int fFinalDefault; |
| int fTargetNSURI; |
| int fScopeCount; |
| unsigned int fNamespaceScopeLevel; |
| XMLCh* fCurrentSchemaURL; |
| const XMLCh* fTargetNSURIString; |
| const DOMElement* fSchemaRootElement; |
| RefVectorOf<SchemaInfo>* fIncludeInfoList; |
| RefVectorOf<SchemaInfo>* fImportedInfoList; |
| RefVectorOf<SchemaInfo>* fImportingInfoList; |
| ValueVectorOf<const DOMElement*>* fFailedRedefineList; |
| ValueVectorOf<int>* fImportedNSList; |
| ValueVectorOf<const DOMElement*>* fRecursingAnonTypes; |
| ValueVectorOf<const XMLCh*>* fRecursingTypeNames; |
| RefHashTableOf<DOMElement>* fTopLevelComponents[C_Count]; |
| DOMElement* fLastTopLevelComponent[C_Count]; |
| ValueVectorOf<DOMNode*>* fNonXSAttList; |
| ValidationContext* fValidationContext; |
| MemoryManager* fMemoryManager; |
| }; |
| |
| // --------------------------------------------------------------------------- |
| // SchemaInfo: Getter methods |
| // --------------------------------------------------------------------------- |
| inline unsigned short SchemaInfo::getElemAttrDefaultQualified() const { |
| |
| return fElemAttrDefaultQualified; |
| } |
| |
| inline bool SchemaInfo::getProcessed() const { |
| |
| return fProcessed; |
| } |
| |
| inline int SchemaInfo::getBlockDefault() const { |
| |
| return fBlockDefault; |
| } |
| |
| inline int SchemaInfo::getFinalDefault() const { |
| |
| return fFinalDefault; |
| } |
| |
| inline unsigned int SchemaInfo::getNamespaceScopeLevel() const { |
| return fNamespaceScopeLevel; |
| } |
| |
| inline XMLCh* SchemaInfo::getCurrentSchemaURL() const { |
| |
| return fCurrentSchemaURL; |
| } |
| |
| inline const XMLCh* const SchemaInfo::getTargetNSURIString() const { |
| |
| return fTargetNSURIString; |
| } |
| |
| inline const DOMElement* SchemaInfo::getRoot() const { |
| |
| return fSchemaRootElement; |
| } |
| |
| inline int SchemaInfo::getTargetNSURI() const { |
| |
| return fTargetNSURI; |
| } |
| |
| inline int SchemaInfo::getScopeCount() const { |
| |
| return fScopeCount; |
| } |
| |
| inline BaseRefVectorEnumerator<SchemaInfo> |
| SchemaInfo::getImportingListEnumerator() const { |
| |
| return BaseRefVectorEnumerator<SchemaInfo>(fImportingInfoList); |
| } |
| |
| inline ValueVectorOf<const DOMElement*>* |
| SchemaInfo::getRecursingAnonTypes() const { |
| |
| return fRecursingAnonTypes; |
| } |
| |
| |
| inline ValueVectorOf<const XMLCh*>* |
| SchemaInfo::getRecursingTypeNames() const { |
| |
| return fRecursingTypeNames; |
| } |
| |
| inline ValueVectorOf<DOMNode*>* SchemaInfo::getNonXSAttList() const |
| { |
| return fNonXSAttList; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Setter methods |
| // --------------------------------------------------------------------------- |
| inline void SchemaInfo::setScopeCount(const int aValue) { |
| |
| fScopeCount = aValue; |
| } |
| |
| inline void SchemaInfo::setBlockDefault(const int aValue) { |
| |
| fBlockDefault = aValue; |
| } |
| |
| inline void SchemaInfo::setFinalDefault(const int aValue) { |
| |
| fFinalDefault = aValue; |
| } |
| |
| inline void SchemaInfo::setElemAttrDefaultQualified(const unsigned short aValue) { |
| |
| fElemAttrDefaultQualified = aValue; |
| } |
| |
| inline void SchemaInfo::setProcessed(const bool aValue) { |
| |
| fProcessed = aValue; |
| |
| /* if (fProcessed && fIncludeInfoList) { |
| |
| unsigned int includeListLen = fIncludeInfoList->size()); |
| for (unsigned int i = 0; i < includeListLen; i++) { |
| fIncludeInfoList->elementAt(i)->clearTopLevelComponents(); |
| } |
| }*/ |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SchemaInfo: Access methods |
| // --------------------------------------------------------------------------- |
| inline void SchemaInfo::addImportedNS(const int namespaceURI) { |
| |
| if (!fImportedNSList) { |
| fImportedNSList = new (fMemoryManager) ValueVectorOf<int>(4, fMemoryManager); |
| } |
| |
| if (!fImportedNSList->containsElement(namespaceURI)) |
| fImportedNSList->addElement(namespaceURI); |
| } |
| |
| inline void SchemaInfo::addSchemaInfo(SchemaInfo* const toAdd, |
| const ListType aListType) { |
| |
| if (aListType == IMPORT) { |
| |
| if (!fImportedInfoList) |
| fImportedInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(4, false, fMemoryManager); |
| |
| if (!fImportedInfoList->containsElement(toAdd)) { |
| |
| fImportedInfoList->addElement(toAdd); |
| addImportedNS(toAdd->getTargetNSURI()); |
| toAdd->updateImportingInfo(this); |
| } |
| } |
| else { |
| |
| if (!fIncludeInfoList) { |
| |
| fIncludeInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(8, false, fMemoryManager); |
| fAdoptInclude = true; |
| } |
| |
| if (!fIncludeInfoList->containsElement(toAdd)) { |
| |
| fIncludeInfoList->addElement(toAdd); |
| toAdd->fIncludeInfoList = fIncludeInfoList; |
| } |
| } |
| } |
| |
| inline SchemaInfo* SchemaInfo::getImportInfo(const unsigned int namespaceURI) const { |
| |
| unsigned int importSize = (fImportedInfoList) ? fImportedInfoList->size() : 0; |
| SchemaInfo* currInfo = 0; |
| |
| for (unsigned int i=0; i < importSize; i++) { |
| |
| currInfo = fImportedInfoList->elementAt(i); |
| |
| if (currInfo->getTargetNSURI() == (int) namespaceURI) |
| break; |
| } |
| |
| return currInfo; |
| } |
| |
| inline ValidationContext* SchemaInfo::getValidationContext() const { |
| |
| return fValidationContext; |
| } |
| |
| inline bool SchemaInfo::containsInfo(const SchemaInfo* const toCheck, |
| const ListType aListType) const { |
| |
| if ((aListType == INCLUDE) && fIncludeInfoList) { |
| return fIncludeInfoList->containsElement(toCheck); |
| } |
| else if ((aListType == IMPORT) && fImportedInfoList) { |
| return fImportedInfoList->containsElement(toCheck); |
| } |
| |
| return false; |
| } |
| |
| inline bool SchemaInfo::circularImportExist(const unsigned int namespaceURI) { |
| |
| unsigned int importSize = fImportingInfoList->size(); |
| |
| for (unsigned int i=0; i < importSize; i++) { |
| if (fImportingInfoList->elementAt(i)->getTargetNSURI() == (int) namespaceURI) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| inline bool SchemaInfo::isFailedRedefine(const DOMElement* const anElem) { |
| |
| if (fFailedRedefineList) |
| return (fFailedRedefineList->containsElement(anElem)); |
| |
| return false; |
| } |
| |
| inline void SchemaInfo::addFailedRedefine(const DOMElement* const anElem) { |
| |
| if (!fFailedRedefineList) { |
| fFailedRedefineList = new (fMemoryManager) ValueVectorOf<const DOMElement*>(4, fMemoryManager); |
| } |
| |
| fFailedRedefineList->addElement(anElem); |
| } |
| |
| inline bool SchemaInfo::isImportingNS(const int namespaceURI) { |
| |
| if (!fImportedNSList) |
| return false; |
| |
| return (fImportedNSList->containsElement(namespaceURI)); |
| } |
| |
| inline void SchemaInfo::addRecursingType(const DOMElement* const elem, |
| const XMLCh* const name) { |
| |
| if (!fRecursingAnonTypes) { |
| fRecursingAnonTypes = new (fMemoryManager) ValueVectorOf<const DOMElement*>(8, fMemoryManager); |
| fRecursingTypeNames = new (fMemoryManager) ValueVectorOf<const XMLCh*>(8, fMemoryManager); |
| } |
| |
| fRecursingAnonTypes->addElement(elem); |
| fRecursingTypeNames->addElement(name); |
| } |
| |
| inline void SchemaInfo::clearTopLevelComponents() { |
| |
| for (unsigned int i = 0; i < C_Count; i++) { |
| |
| delete fTopLevelComponents[i]; |
| fTopLevelComponents[i] = 0; |
| fLastTopLevelComponent[i] = 0; |
| } |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| #endif |
| |
| /** |
| * End of file SchemaInfo.hpp |
| */ |
| |
