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 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 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;
}
}
public void Add(IValue value)
{
IXSComponent Value = (IXSComponent)value;
if (!(Value is IXSComponent))
{
throw RuntimeException.InvalidArgumentType();
}
_items.Add(Value);
_owner.OnListInsert(this, Value);
}
private void Content_Inserted(object sender, XSComponentListEventArgs e)
{
IXSComponent component = e.Component;
if (!(component is IXSAnnotationItem))
{
throw RuntimeException.InvalidArgumentType();
}
component.BindToContainer(RootContainer, this);
Components.Add(component);
InternalObject.Items.Add(component.SchemaObject);
}
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;
}
public void Insert(int index, IXSComponent value)
{
//=> _items.Insert(index, value);
throw new NotImplementedException();
}
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;
}
public void OnListInsert(XSComponentList List, IXSComponent component)
{
component.BindToContainer(_rootContainer, this);
InternalObject.Items.Add(component.XmlSchemaObject);
Components.Add(component);
}
public void BindToContainer(IXSComponent rootContainer, IXSComponent container)
{
_rootContainer = rootContainer;
_container = container;
}
private void InvokeEventDeleted(IXSComponent component) => Deleted?.Invoke(this, new XSComponentListEventArgs(component));
public XSComponentListEventArgs(IXSComponent component) => Component = component;
public bool Contains(IXSComponent component) => Components.Contains(component);
public Boolean Contains(IXSComponent value)
{
throw new NotImplementedException();
}
public void Set(int index, IXSComponent value)
{
throw new NotImplementedException();
}
public void OnListDelete(XSComponentList List, IXSComponent component)
{
}
