protected virtual void Visit(XmlSchemaContent content)
{
XmlSchemaSimpleContentExtension simpleContentExtension;
XmlSchemaSimpleContentRestriction simpleContentRestriction;
XmlSchemaComplexContentExtension complexContentExtension;
XmlSchemaComplexContentRestriction complexContentRestriction;
if (Casting.TryCast(content, out simpleContentExtension))
{
Visit(simpleContentExtension);
}
else if (Casting.TryCast(content, out simpleContentRestriction))
{
Visit(simpleContentRestriction);
}
else if (Casting.TryCast(content, out complexContentExtension))
{
Visit(complexContentExtension);
}
else if (Casting.TryCast(content, out complexContentRestriction))
{
Visit(complexContentRestriction);
}
else
{
throw ExceptionBuilder.UnexpectedSchemaObjectType(content);
}
}
private XmlSchemaContent Copy(XmlSchemaContent content)
{
XmlSchemaComplexContentExtension extension = content as XmlSchemaComplexContentExtension;
XmlSchemaComplexContentRestriction restriction = content as XmlSchemaComplexContentRestriction;
if (extension != null)
{
XmlSchemaComplexContentExtension newExtension = new XmlSchemaComplexContentExtension();
if (extension.BaseTypeName != null)
{
CopyDataType(extension.BaseTypeName.Name);
newExtension.BaseTypeName = new XmlQualifiedName(extension.BaseTypeName.Name, this.ns);
}
if (extension.Particle != null)
{
XmlSchemaParticle newParticle = Copy(extension.Particle);
newExtension.Particle = newParticle;
}
foreach (var attribute in extension.Attributes.Cast <XmlSchemaAttribute>())
{
XmlSchemaAttribute newAttribute = this.Copy(attribute);
newExtension.Attributes.Add(newAttribute);
}
return(newExtension);
}
if (restriction != null)
{
XmlSchemaComplexContentRestriction newRestriction = new XmlSchemaComplexContentRestriction();
if (restriction.BaseTypeName != null)
{
CopyDataType(restriction.BaseTypeName.Name);
newRestriction.BaseTypeName = new XmlQualifiedName(restriction.BaseTypeName.Name, this.ns);
}
if (restriction.Particle != null)
{
XmlSchemaParticle newParticle = Copy(restriction.Particle);
newRestriction.Particle = newParticle;
}
foreach (var attribute in restriction.Attributes.Cast <XmlSchemaAttribute>())
{
XmlSchemaAttribute newAttribute = this.Copy(attribute);
newRestriction.Attributes.Add(newAttribute);
}
return(newRestriction);
}
throw new Exception("Unexpected XmlSchemaComplexContent type (not extension or restriction)");
}
private void CopyDataType(XmlSchemaComplexType complexType)
{
if (FindDataType(destinationSchema, complexType.Name) != null)
{
return;
}
XmlSchemaComplexType newComplexType = new XmlSchemaComplexType()
{
Name = complexType.Name,
IsMixed = complexType.IsMixed,
IsAbstract = complexType.IsAbstract,
};
destinationSchema.Items.Add(newComplexType);
// Add annotation to indicate where it was copied from
newComplexType.Annotation = CreateAnnotation("Data type copied from base schema (" + sourceSchema.TargetNamespace + ")");
// Copy children
XmlSchemaSequence particleSequence = complexType.Particle as XmlSchemaSequence;
XmlSchemaComplexContent complexContent = complexType.ContentModel as XmlSchemaComplexContent;
if (particleSequence != null)
{
XmlSchemaSequence newParticleSequence = new XmlSchemaSequence();
newComplexType.Particle = newParticleSequence;
foreach (var currentObject in particleSequence.Items)
{
if (currentObject is XmlSchemaElement)
{
XmlSchemaElement newElement = Copy(currentObject as XmlSchemaElement);
newParticleSequence.Items.Add(newElement);
}
}
}
else if (complexContent != null)
{
XmlSchemaComplexContent newComplexContent = new XmlSchemaComplexContent();
newComplexType.ContentModel = newComplexContent;
newComplexContent.IsMixed = complexContent.IsMixed;
if (complexContent.Content != null)
{
XmlSchemaContent newContent = Copy(complexContent.Content);
newComplexContent.Content = newContent;
}
}
foreach (var attribute in complexType.Attributes.Cast <XmlSchemaAttribute>())
{
XmlSchemaAttribute newAttribute = this.Copy(attribute);
newComplexType.Attributes.Add(newAttribute);
}
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if (item == null || scope[item] != null)
{
return;
}
Type t = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(t))
{
XmlQualifiedName baseName = XmlQualifiedName.Empty;
XmlSchemaType baseType = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = (XmlSchemaComplexType)item;
if (ct.ContentModel != null)
{
XmlSchemaContent content = ct.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
baseName = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
baseType = restriction.BaseType;
}
else
{
baseName = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
baseName = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content;
attributes = extension.Attributes;
baseName = extension.BaseTypeName;
}
}
else
{
attributes = ct.Attributes;
particle = ct.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef refGroup = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)schemas.Find(refGroup.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content = simpleType.Content;
if (content is XmlSchemaSimpleTypeRestriction)
{
baseType = ((XmlSchemaSimpleTypeRestriction)content).BaseType;
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content;
if (list.ItemTypeName != null && !list.ItemTypeName.IsEmpty)
{
baseName = list.ItemTypeName;
}
if (list.ItemType != null)
{
baseType = list.ItemType;
}
}
else if (content is XmlSchemaSimpleTypeRestriction)
{
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (t == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
if (baseType == null && !baseName.IsEmpty && baseName.Namespace != XmlSchema.Namespace)
{
baseType = (XmlSchemaType)schemas.Find(baseName, typeof(XmlSchemaType), false);
}
if (baseType != null)
{
AddRef(refs, baseType);
}
if (particle != null)
{
Depends(particle, refs);
}
if (attributes != null)
{
for (int i = 0; i < attributes.Count; i++)
{
Depends(attributes[i], refs);
}
}
}
else if (t == typeof(XmlSchemaElement))
{
XmlSchemaElement el = (XmlSchemaElement)item;
if (!el.SubstitutionGroup.IsEmpty)
{
if (el.SubstitutionGroup.Namespace != XmlSchema.Namespace)
{
XmlSchemaElement head = (XmlSchemaElement)schemas.Find(el.SubstitutionGroup, typeof(XmlSchemaElement), false);
AddRef(refs, head);
}
}
if (!el.RefName.IsEmpty)
{
el = (XmlSchemaElement)schemas.Find(el.RefName, typeof(XmlSchemaElement), false);
AddRef(refs, el);
}
else if (!el.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(el.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(el.SchemaType, refs);
}
}
else if (t == typeof(XmlSchemaGroup))
{
Depends(((XmlSchemaGroup)item).Particle);
}
else if (t == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(t))
{
foreach (XmlSchemaObject o in ((XmlSchemaGroupBase)item).Items)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group = (XmlSchemaAttributeGroup)schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
AddRef(refs, group);
}
else if (t == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject o in ((XmlSchemaAttributeGroup)item).Attributes)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute at = (XmlSchemaAttribute)item;
if (!at.RefName.IsEmpty)
{
at = (XmlSchemaAttribute)schemas.Find(at.RefName, typeof(XmlSchemaAttribute), false);
AddRef(refs, at);
}
else if (!at.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(at.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(at.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(t))
{
XmlAttribute[] attrs = (XmlAttribute[])((XmlSchemaAnnotated)item).UnhandledAttributes;
if (attrs != null)
{
for (int i = 0; i < attrs.Length; i++)
{
XmlAttribute attribute = attrs[i];
if (attribute.LocalName == Wsdl.ArrayType && attribute.NamespaceURI == Wsdl.Namespace)
{
string dims;
XmlQualifiedName qname = TypeScope.ParseWsdlArrayType(attribute.Value, out dims, item);
XmlSchemaType type = (XmlSchemaType)schemas.Find(qname, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
}
void ExportAttributeAccessor(XmlSchemaComplexType type, AttributeAccessor accessor, bool valueTypeOptional, string ns)
{
if (accessor == null)
{
return;
}
XmlSchemaObjectCollection attributes;
if (type.ContentModel != null)
{
if (type.ContentModel.Content is XmlSchemaComplexContentRestriction)
{
attributes = ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Attributes;
}
else if (type.ContentModel.Content is XmlSchemaComplexContentExtension)
{
attributes = ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Attributes;
}
else if (type.ContentModel.Content is XmlSchemaSimpleContentExtension)
{
attributes = ((XmlSchemaSimpleContentExtension)type.ContentModel.Content).Attributes;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name));
}
}
else
{
attributes = type.Attributes;
}
if (accessor.IsSpecialXmlNamespace)
{
// add <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
AddSchemaImport(XmlReservedNs.NsXml, ns);
// generate <xsd:attribute ref="xml:lang" use="optional" />
XmlSchemaAttribute attribute = new XmlSchemaAttribute();
attribute.Use = XmlSchemaUse.Optional;
attribute.RefName = new XmlQualifiedName(accessor.Name, XmlReservedNs.NsXml);
attributes.Add(attribute);
}
else if (accessor.Any)
{
if (type.ContentModel == null)
{
type.AnyAttribute = new XmlSchemaAnyAttribute();
}
else
{
XmlSchemaContent content = type.ContentModel.Content;
if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
extension.AnyAttribute = new XmlSchemaAnyAttribute();
}
else if (content is XmlSchemaComplexContentRestriction)
{
XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)content;
restriction.AnyAttribute = new XmlSchemaAnyAttribute();
}
}
}
else
{
XmlSchemaAttribute attribute = new XmlSchemaAttribute();
attribute.Use = XmlSchemaUse.None;
if (!accessor.HasDefault && !valueTypeOptional && accessor.Mapping.TypeDesc.IsValueType)
{
attribute.Use = XmlSchemaUse.Required;
}
attribute.Name = accessor.Name;
if (accessor.Namespace == null || accessor.Namespace == ns)
{
// determine the form attribute value
XmlSchema schema = schemas[ns];
if (schema == null)
{
attribute.Form = accessor.Form == attributeFormDefault ? XmlSchemaForm.None : accessor.Form;
}
else
{
attribute.Form = accessor.Form == schema.AttributeFormDefault ? XmlSchemaForm.None : accessor.Form;
}
attributes.Add(attribute);
}
else
{
// we are going to add the attribute to the top-level items. "use" attribute should not be set
attribute.Use = XmlSchemaUse.None;
attribute.Form = accessor.Form;
AddSchemaItem(attribute, accessor.Namespace, ns);
XmlSchemaAttribute refAttribute = new XmlSchemaAttribute();
refAttribute.Use = XmlSchemaUse.None;
refAttribute.RefName = new XmlQualifiedName(accessor.Name, accessor.Namespace);
attributes.Add(refAttribute);
}
if (accessor.Mapping is PrimitiveMapping)
{
PrimitiveMapping pm = (PrimitiveMapping)accessor.Mapping;
if (pm.IsList)
{
// create local simple type for the list-like attributes
XmlSchemaSimpleType dataType = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
list.ItemTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace);
dataType.Content = list;
attribute.SchemaType = dataType;
}
else
{
attribute.SchemaTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace);
}
}
else if (!(accessor.Mapping is SpecialMapping))
{
throw new InvalidOperationException(Res.GetString(Res.XmlInternalError));
}
if (accessor.HasDefault && accessor.Mapping.TypeDesc.HasDefaultSupport)
{
attribute.DefaultValue = ExportDefaultValue(accessor.Mapping, accessor.Default);
}
}
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if ((item != null) && (this.scope[item] == null))
{
Type c = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(c))
{
XmlQualifiedName empty = XmlQualifiedName.Empty;
XmlSchemaType o = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType type3 = (XmlSchemaComplexType)item;
if (type3.ContentModel != null)
{
XmlSchemaContent content = type3.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
empty = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
o = restriction.BaseType;
}
else
{
empty = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
empty = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension2 = (XmlSchemaSimpleContentExtension)content;
attributes = extension2.Attributes;
empty = extension2.BaseTypeName;
}
}
else
{
attributes = type3.Attributes;
particle = type3.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef ref2 = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)this.schemas.Find(ref2.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType type4 = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content2 = type4.Content;
if (content2 is XmlSchemaSimpleTypeRestriction)
{
o = ((XmlSchemaSimpleTypeRestriction)content2).BaseType;
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (content2 is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content2;
if ((list.ItemTypeName != null) && !list.ItemTypeName.IsEmpty)
{
empty = list.ItemTypeName;
}
if (list.ItemType != null)
{
o = list.ItemType;
}
}
else if (content2 is XmlSchemaSimpleTypeRestriction)
{
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (c == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type5 = (XmlSchemaType)this.schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
this.AddRef(refs, type5);
}
}
}
}
if (((o == null) && !empty.IsEmpty) && (empty.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
o = (XmlSchemaType)this.schemas.Find(empty, typeof(XmlSchemaType), false);
}
if (o != null)
{
this.AddRef(refs, o);
}
if (particle != null)
{
this.Depends(particle, refs);
}
if (attributes != null)
{
for (int j = 0; j < attributes.Count; j++)
{
this.Depends(attributes[j], refs);
}
}
}
else if (c == typeof(XmlSchemaElement))
{
XmlSchemaElement element = (XmlSchemaElement)item;
if (!element.SubstitutionGroup.IsEmpty && (element.SubstitutionGroup.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
XmlSchemaElement element2 = (XmlSchemaElement)this.schemas.Find(element.SubstitutionGroup, typeof(XmlSchemaElement), false);
this.AddRef(refs, element2);
}
if (!element.RefName.IsEmpty)
{
element = (XmlSchemaElement)this.schemas.Find(element.RefName, typeof(XmlSchemaElement), false);
this.AddRef(refs, element);
}
else if (!element.SchemaTypeName.IsEmpty)
{
XmlSchemaType type6 = (XmlSchemaType)this.schemas.Find(element.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type6);
}
else
{
this.Depends(element.SchemaType, refs);
}
}
else if (c == typeof(XmlSchemaGroup))
{
this.Depends(((XmlSchemaGroup)item).Particle);
}
else if (c == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)this.schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
this.AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(c))
{
foreach (XmlSchemaObject obj2 in ((XmlSchemaGroupBase)item).Items)
{
this.Depends(obj2, refs);
}
}
else if (c == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group2 = (XmlSchemaAttributeGroup)this.schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
this.AddRef(refs, group2);
}
else if (c == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject obj3 in ((XmlSchemaAttributeGroup)item).Attributes)
{
this.Depends(obj3, refs);
}
}
else if (c == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)item;
if (!attribute.RefName.IsEmpty)
{
attribute = (XmlSchemaAttribute)this.schemas.Find(attribute.RefName, typeof(XmlSchemaAttribute), false);
this.AddRef(refs, attribute);
}
else if (!attribute.SchemaTypeName.IsEmpty)
{
XmlSchemaType type7 = (XmlSchemaType)this.schemas.Find(attribute.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type7);
}
else
{
this.Depends(attribute.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(c))
{
XmlAttribute[] unhandledAttributes = ((XmlSchemaAnnotated)item).UnhandledAttributes;
if (unhandledAttributes != null)
{
for (int k = 0; k < unhandledAttributes.Length; k++)
{
XmlAttribute attribute2 = unhandledAttributes[k];
if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/"))
{
string str;
XmlQualifiedName name = TypeScope.ParseWsdlArrayType(attribute2.Value, out str, item);
XmlSchemaType type8 = (XmlSchemaType)this.schemas.Find(name, typeof(XmlSchemaType), false);
this.AddRef(refs, type8);
}
}
}
}
}
}
private void IterateOverElement(string root, XmlSchemaElement element)
{
var complexType = element.SchemaType as XmlSchemaComplexType;
if (complexType == null)
{
return;
}
if (complexType.AttributeUses.Count > 0)
{
IDictionaryEnumerator enumerator = complexType.AttributeUses.GetEnumerator();
while (enumerator.MoveNext())
{
var attribute = (XmlSchemaAttribute)enumerator.Value;
Console.WriteLine(root + @"." + attribute.Name + @" (attribute)");
}
}
XmlSchemaContentModel contentModel = complexType.ContentModel;
if (contentModel == null)
{
return;
}
XmlSchemaContent content = contentModel.Content;
if (content is XmlSchemaComplexContentExtension)
{
var ext = (XmlSchemaComplexContentExtension)content;
XmlQualifiedName baseTypeField = ext.BaseTypeName;
_baseSignalName = baseTypeField.Name;
_baseSignalNameSpace = baseTypeField.Namespace; //Need to get the base target namespace
foreach (XmlSchemaObject o in ext.Attributes)
{
var attribute = (XmlSchemaAttribute)o;
XmlSchemaAnnotation annotation = attribute.Annotation;
XmlSchemaType schemaType = attribute.SchemaType;
String defaultValue = attribute.DefaultValue;
String fixedValue = attribute.FixedValue;
String name = attribute.Name;
var signalAttribute = new SignalAttribute(name);
signalAttribute.DefaultValue = defaultValue;
signalAttribute.FixedValue = fixedValue;
signalAttribute.SchemaType = attribute.SchemaTypeName.Name;
_attributes.Add(signalAttribute);
//Add AttributeRestrictions here
if (schemaType is XmlSchemaSimpleType)
{
var simpleType = (XmlSchemaSimpleType)schemaType;
XmlSchemaSimpleTypeContent simpleContent = simpleType.Content;
foreach (XmlAttribute ua in simpleContent.UnhandledAttributes)
{
//if( "minInclusive".Equals( ua.LocalName )
// restriction = new RangeRestriction(
//Console.WriteLine("\t\t\t\t" + ua.Name + "\t\t" + ua.Value);
var restriction = new AttributeRestriction(ua);
signalAttribute.AddRestriction(restriction);
}
}
}
}
}
