XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XSMultiValueFacet: Constructors and Destructors
// ---------------------------------------------------------------------------
XSMultiValueFacet::XSMultiValueFacet(XSSimpleTypeDefinition::FACET facetKind,
StringList* lexicalValues,
bool isFixed,
XSAnnotation* const headAnnot,
XSModel* const xsModel,
MemoryManager* const manager)
: XSObject(XSConstants::MULTIVALUE_FACET, xsModel, manager)
, fFacetKind(facetKind)
, fIsFixed(isFixed)
, fLexicalValues(lexicalValues)
, fXSAnnotationList(0)
{
if (headAnnot)
{
fXSAnnotationList = new (manager) RefVectorOf<XSAnnotation>(1, false, manager);
XSAnnotation* annot = headAnnot;
do
{
fXSAnnotationList->addElement(annot);
annot = annot->getNext();
} while (annot);
}
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XSIDCDefinition: Constructors and Destructor
// ---------------------------------------------------------------------------
XSIDCDefinition::XSIDCDefinition(IdentityConstraint* const identityConstraint,
XSIDCDefinition* const keyIC,
XSAnnotation* const headAnnot,
StringList* const stringList,
XSModel* const xsModel,
MemoryManager* const manager)
: XSObject(XSConstants::IDENTITY_CONSTRAINT, xsModel, manager)
, fIdentityConstraint(identityConstraint)
, fKey(keyIC)
, fStringList(stringList)
, fXSAnnotationList(0)
{
if (headAnnot)
{
fXSAnnotationList = new (manager) RefVectorOf<XSAnnotation>(1, false, manager);
XSAnnotation* annot = headAnnot;
do
{
fXSAnnotationList->addElement(annot);
annot = annot->getNext();
} while (annot);
}
}
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XSComplexTypeDefinition: Constructors and Destructor
// ---------------------------------------------------------------------------
XSComplexTypeDefinition::XSComplexTypeDefinition
(
ComplexTypeInfo* const complexTypeInfo
, XSWildcard* const xsWildcard
, XSSimpleTypeDefinition* const xsSimpleType
, XSAttributeUseList* const xsAttList
, XSTypeDefinition* const xsBaseType
, XSParticle* const xsParticle
, XSAnnotation* const headAnnot
, XSModel* const xsModel
, MemoryManager* const manager
)
: XSTypeDefinition(COMPLEX_TYPE, xsBaseType, xsModel, manager)
, fComplexTypeInfo(complexTypeInfo)
, fXSWildcard(xsWildcard)
, fXSAttributeUseList(xsAttList)
, fXSSimpleTypeDefinition(xsSimpleType)
, fXSAnnotationList(0)
, fParticle(xsParticle)
, fProhibitedSubstitution(0)
{
int blockset = fComplexTypeInfo->getBlockSet();
if (blockset)
{
if (blockset & SchemaSymbols::XSD_EXTENSION)
fProhibitedSubstitution |= XSConstants::DERIVATION_EXTENSION;
if (blockset & SchemaSymbols::XSD_RESTRICTION)
fProhibitedSubstitution |= XSConstants::DERIVATION_RESTRICTION;
}
int finalSet = fComplexTypeInfo->getFinalSet();
if (finalSet)
{
if (finalSet & SchemaSymbols::XSD_EXTENSION)
fFinal |= XSConstants::DERIVATION_EXTENSION;
if (finalSet & SchemaSymbols::XSD_RESTRICTION)
fFinal |= XSConstants::DERIVATION_RESTRICTION;
}
if (headAnnot)
{
fXSAnnotationList = new (manager) RefVectorOf<XSAnnotation>(1, false, manager);
XSAnnotation* annot = headAnnot;
do
{
fXSAnnotationList->addElement(annot);
annot = annot->getNext();
} while (annot);
}
}
void SchemaGrammar::addAnnotation(XSAnnotation* const annotation)
{
XSAnnotation* lAnnot = fAnnotations->get(this);
if (lAnnot)
lAnnot->setNext(annotation);
else
fAnnotations->put(this, annotation);
}
// ---------------------------------------------------------------------------
// XSSimpleTypeDefinition: Constructors and Destructors
// ---------------------------------------------------------------------------
XSSimpleTypeDefinition::XSSimpleTypeDefinition
(
DatatypeValidator* const datatypeValidator
, VARIETY stVariety
, XSTypeDefinition* const xsBaseType
, XSSimpleTypeDefinition* const primitiveOrItemType
, XSSimpleTypeDefinitionList* const memberTypes
, XSAnnotation* headAnnot
, XSModel* const xsModel
, MemoryManager* const manager
)
: XSTypeDefinition(SIMPLE_TYPE, xsBaseType, xsModel, manager)
, fDefinedFacets(0)
, fFixedFacets(0)
, fVariety(stVariety)
, fDatatypeValidator(datatypeValidator)
, fXSFacetList(0)
, fXSMultiValueFacetList(0)
, fPatternList(0)
, fPrimitiveOrItemType(primitiveOrItemType)
, fMemberTypes(memberTypes)
, fXSAnnotationList(0)
{
int finalset = fDatatypeValidator->getFinalSet();
if (finalset)
{
if (finalset & SchemaSymbols::XSD_EXTENSION)
fFinal |= XSConstants::DERIVATION_EXTENSION;
if (finalset & SchemaSymbols::XSD_RESTRICTION)
fFinal |= XSConstants::DERIVATION_RESTRICTION;
if (finalset & SchemaSymbols::XSD_LIST)
fFinal |= XSConstants::DERIVATION_LIST;
if (finalset & SchemaSymbols::XSD_UNION)
fFinal |= XSConstants::DERIVATION_UNION;
}
if (headAnnot)
{
XSAnnotation* annot = headAnnot;
fXSAnnotationList = new (manager) RefVectorOf<XSAnnotation>(3, false, manager);
do
{
fXSAnnotationList->addElement(annot);
annot = annot->getNext();
} while (annot);
}
}
void XSModel::addGrammarToXSModel(XSNamespaceItem* namespaceItem)
{
// Loop through top-level attribute declarations in the grammar...
RefHashTableOf<XMLAttDef>* attDeclRegistry = namespaceItem->fGrammar->getAttributeDeclRegistry();
if(attDeclRegistry) {
RefHashTableOfEnumerator<XMLAttDef> attrEnum = RefHashTableOfEnumerator<XMLAttDef> (attDeclRegistry, false, fMemoryManager);
while (attrEnum.hasMoreElements())
{
XSAttributeDeclaration* xsAttrDecl = fObjFactory->addOrFind
(
(SchemaAttDef*) &(attrEnum.nextElement()), this
);
addComponentToNamespace
(
namespaceItem, xsAttrDecl, XSConstants::ATTRIBUTE_DECLARATION - 1
);
} // end of attribute loop
}
// Loop through top-level elements in the grammar...
RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = namespaceItem->fGrammar->getElemEnumerator();
while (elemEnum.hasMoreElements())
{
SchemaElementDecl& curElem = elemEnum.nextElement();
if (curElem.getEnclosingScope() == Grammar::TOP_LEVEL_SCOPE)
{
XSElementDeclaration* xsElemDecl = fObjFactory->addOrFind
(
&curElem, this
);
addComponentToNamespace
(
namespaceItem, xsElemDecl, XSConstants::ELEMENT_DECLARATION -1
);
}
} // end of element loop
// Now loop through top-level User Defined simple type definitions in the grammar...
DVHashTable* dvHT = namespaceItem->fGrammar->getDatatypeRegistry()->getUserDefinedRegistry();
if (dvHT)
{
RefHashTableOfEnumerator<DatatypeValidator> simpleUserEnum = RefHashTableOfEnumerator<DatatypeValidator> (dvHT, false, fMemoryManager);
while (simpleUserEnum.hasMoreElements())
{
DatatypeValidator& curSimple = simpleUserEnum.nextElement();
if (!curSimple.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curSimple, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of simple User loop
}
// Loop through top-level COMPLEX type definitions in the grammar...
RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = namespaceItem->fGrammar->getComplexTypeRegistry();
if(complexTypeRegistry) {
RefHashTableOfEnumerator<ComplexTypeInfo> complexEnum = RefHashTableOfEnumerator<ComplexTypeInfo> (complexTypeRegistry, false, fMemoryManager);
while (complexEnum.hasMoreElements())
{
ComplexTypeInfo& curComplex = complexEnum.nextElement();
if (!curComplex.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curComplex, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of type definition loop
}
// Loop through top-level attribute group definitions in the grammar...
RefHashTableOf<XercesAttGroupInfo>* attGroupInfoRegistry = namespaceItem->fGrammar->getAttGroupInfoRegistry();
if(attGroupInfoRegistry) {
RefHashTableOfEnumerator<XercesAttGroupInfo> attrGroupEnum = RefHashTableOfEnumerator<XercesAttGroupInfo> (attGroupInfoRegistry, false, fMemoryManager);
while (attrGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSAttGroupDefinition
(
&(attrGroupEnum.nextElement()), this
)
, XSConstants::ATTRIBUTE_GROUP_DEFINITION - 1
);
} // end of attribute group loop
}
// Loop through top-level model group definitions in the grammar...
RefHashTableOf<XercesGroupInfo>* groupInfoRegistry = namespaceItem->fGrammar->getGroupInfoRegistry();
if(groupInfoRegistry) {
RefHashTableOfEnumerator<XercesGroupInfo> modelGroupEnum = RefHashTableOfEnumerator<XercesGroupInfo> (groupInfoRegistry, false, fMemoryManager);
while (modelGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSModelGroupDefinition
(
&(modelGroupEnum.nextElement()), this
)
, XSConstants::MODEL_GROUP_DEFINITION - 1
);
} // end of model group loop
}
// Loop through notations in the grammar...
NameIdPoolEnumerator<XMLNotationDecl> notationEnum = namespaceItem->fGrammar->getNotationEnumerator();
while (notationEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&(notationEnum.nextElement()), this)
, XSConstants::NOTATION_DECLARATION - 1
);
} // end of notation loop
// Loop through annotations in the grammar...
// As annotations are already created as XSAnnotations no need to create them
// or store them in the XercesToXSMap.
XSAnnotation* annot = namespaceItem->fGrammar->getAnnotation();
while (annot)
{
fXSAnnotationList->addElement(annot);
namespaceItem->fXSAnnotationList->addElement(annot);
addComponentToIdVector(annot, XSConstants::ANNOTATION -1);
annot = annot->getNext();
} // end of annotation loop
}