internal XSAttributeGroupDefinition(XmlSchemaAttributeGroup xmlAttributeGroup)
: this()
{
_attributeGroup = xmlAttributeGroup;
_name = xmlAttributeGroup.Name;
if (_attributeGroup.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (xmlAttributeGroup.AnyAttribute is XmlSchemaAnyAttribute xmlAnyAttribute)
{
_wildcard = XMLSchemaSerializer.CreateXSWildcard(xmlAnyAttribute);
}
Content.Inserted -= Content_Inserted;
foreach (XmlSchemaObject item in xmlAttributeGroup.Attributes)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
Content.Add(component);
Components.Add(component);
}
Content.Inserted += Content_Inserted;
}
internal XSModelGroupDefinition(XmlSchemaGroup xmlGroup)
{
_group = xmlGroup;
_name = xmlGroup.Name;
if (_group.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (xmlGroup.Particle is XmlSchemaGroupBase xmlGroupBase)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(xmlGroupBase);
if (component is XSParticle particle)
{
_modelGroup = particle;
}
else if (component is XSModelGroup modelGroup)
{
_modelGroup = modelGroup;
}
}
}
internal XSSimpleTypeDefinition(XmlSchemaSimpleType simpleType)
: this()
{
_type = simpleType;
if (_type.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (_type.Content is XmlSchemaSimpleTypeList typeList)
{
_variety = XSSimpleTypeVariety.List;
if (typeList.ItemTypeName is XmlQualifiedName qualifiedName)
{
_itemTypeName = new XMLExpandedName(qualifiedName);
}
}
else if (_type.Content is XmlSchemaSimpleTypeUnion typeUnion)
{
_variety = XSSimpleTypeVariety.Union;
MemberTypeDefinitions.Inserted -= MemberTypeDefinitions_Inserted;
foreach (XmlSchemaObject item in typeUnion.BaseTypes)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
MemberTypeDefinitions.Add(component);
Components.Add(component);
}
MemberTypeDefinitions.Inserted += MemberTypeDefinitions_Inserted;
}
else if (_type.Content is XmlSchemaSimpleTypeRestriction typeRestriction)
{
_variety = XSSimpleTypeVariety.Atomic;
if (typeRestriction.BaseTypeName is XmlQualifiedName qualifiedName)
{
_baseTypeName = new XMLExpandedName(qualifiedName);
}
Facets.Inserted -= Facets_Inserted;
foreach (XmlSchemaObject item in typeRestriction.Facets)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
Facets.Add(component);
Components.Add(component);
}
Facets.Inserted += Facets_Inserted;
}
}
internal XSAnnotation(XmlSchemaAnnotation annotation)
: this()
{
InternalObject = annotation;
Content.Inserted -= Content_Inserted;
foreach (XmlSchemaObject item in InternalObject.Items)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
Content.Add(component);
Components.Add(component);
}
Content.Inserted += Content_Inserted;
}
internal XSRedefine(XmlSchemaRedefine redefine)
: this()
{
_redefine = redefine;
Content.Inserted -= Content_Inserted;
Content.Cleared -= Content_Cleared;
foreach (XmlSchemaObject xmlObject in _redefine.Items)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(xmlObject);
component.BindToContainer(RootContainer, this);
Components.Add(component);
Content.Add(component);
}
Content.Inserted += Content_Inserted;
Content.Cleared += Content_Cleared;
}
internal XSModelGroup(XmlSchemaGroupBase groupBase)
: this()
{
_group = groupBase;
if (_group.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (groupBase is XmlSchemaAll)
{
_compositor = XSCompositor.All;
}
else if (groupBase is XmlSchemaChoice)
{
_compositor = XSCompositor.Choice;
}
else if (groupBase is XmlSchemaSequence)
{
_compositor = XSCompositor.Sequence;
}
Particles.Inserted -= Particles_Inserted;
foreach (XmlSchemaObject item in _group.Items)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
Particles.Add(component);
Components.Add(component);
}
Particles.Inserted += Particles_Inserted;
}
internal XSComplexTypeDefinition(XmlSchemaComplexType complexType)
: this()
{
_type = complexType;
if (_type.Annotation is XmlSchemaAnnotation annotation)
{
_annotation = XMLSchemaSerializer.CreateXSAnnotation(annotation);
_annotation.BindToContainer(RootContainer, this);
}
if (_type.ContentModel is XmlSchemaSimpleContent simpleContent)
{
_contentModel = XSContentModel.Simple;
if (simpleContent.Content is XmlSchemaSimpleContentExtension contentExtension)
{
_derivationMethod = XSDerivationMethod.Extension;
if (contentExtension.BaseTypeName is XmlQualifiedName qualifiedName)
{
_baseTypeName = XMLSchemaSerializer.CreateXMLExpandedName(qualifiedName);
}
if (contentExtension.AnyAttribute is XmlSchemaAnyAttribute anyAttribute)
{
_attributeWildcard = XMLSchemaSerializer.CreateXSWildcard(anyAttribute);
}
}
else if (simpleContent.Content is XmlSchemaSimpleContentRestriction contentRestriction)
{
_derivationMethod = XSDerivationMethod.Restriction;
if (contentRestriction.BaseTypeName is XmlQualifiedName qualifiedName)
{
_baseTypeName = XMLSchemaSerializer.CreateXMLExpandedName(qualifiedName);
}
if (contentRestriction.AnyAttribute is XmlSchemaAnyAttribute anyAttribute)
{
_attributeWildcard = XMLSchemaSerializer.CreateXSWildcard(anyAttribute);
}
}
else
{
_derivationMethod = XSDerivationMethod.EmptyRef;
}
if (_type.Particle is XmlSchemaParticle particle)
{
_content = XMLSchemaSerializer.CreateInstance(particle);
}
}
else if (_type.ContentModel is XmlSchemaComplexContent complexContent)
{
_contentModel = XSContentModel.Complex;
if (complexContent.Content is XmlSchemaComplexContentExtension contentExtension)
{
_derivationMethod = XSDerivationMethod.Extension;
if (contentExtension.BaseTypeName is XmlQualifiedName qualifiedName)
{
_baseTypeName = XMLSchemaSerializer.CreateXMLExpandedName(qualifiedName);
}
if (contentExtension.Particle is XmlSchemaParticle particle)
{
_content = XMLSchemaSerializer.CreateInstance(particle);
}
if (contentExtension.AnyAttribute is XmlSchemaAnyAttribute anyAttribute)
{
_attributeWildcard = XMLSchemaSerializer.CreateXSWildcard(anyAttribute);
}
}
else if (complexContent.Content is XmlSchemaComplexContentRestriction contentRestriction)
{
_derivationMethod = XSDerivationMethod.Restriction;
if (contentRestriction.BaseTypeName is XmlQualifiedName qualifiedName)
{
_baseTypeName = XMLSchemaSerializer.CreateXMLExpandedName(qualifiedName);
}
if (contentRestriction.Particle is XmlSchemaParticle particle)
{
_content = XMLSchemaSerializer.CreateInstance(particle);
}
if (contentRestriction.AnyAttribute is XmlSchemaAnyAttribute anyAttribute)
{
_attributeWildcard = XMLSchemaSerializer.CreateXSWildcard(anyAttribute);
}
}
else
{
_derivationMethod = XSDerivationMethod.EmptyRef;
if (_type.Particle is XmlSchemaParticle particle)
{
_content = XMLSchemaSerializer.CreateInstance(particle);
}
}
}
else
{
_contentModel = XSContentModel.EmptyRef;
if (_type.Particle is XmlSchemaParticle particle)
{
_content = XMLSchemaSerializer.CreateInstance(particle);
}
}
Attributes.Inserted -= Attributes_Inserted;
foreach (XmlSchemaObject item in _type.Attributes)
{
IXSComponent component = XMLSchemaSerializer.CreateInstance(item);
component.BindToContainer(RootContainer, this);
Attributes.Add(component);
Components.Add(component);
}
Attributes.Inserted += Attributes_Inserted;
}