private void GetSimpleTypeValues(XmlSchemaSimpleTypeContent content, List <string> resultValues) { var restriction = content as XmlSchemaSimpleTypeRestriction; if (restriction != null) { //just get XmlSchemaEnumerationFacet foreach (var facet in restriction.Facets) { var enumFacet = facet as XmlSchemaEnumerationFacet; if (enumFacet != null) { resultValues.Add(enumFacet.Value); } } } else { var union = content as XmlSchemaSimpleTypeUnion; if (union != null) { foreach (var member in union.MemberTypes) { var simpleType = _simpleTypes.FirstOrDefault(t => t.Name == member.Name); if (simpleType != null) { GetSimpleTypeValues(simpleType.Content, resultValues); } } } } }
public SimpleTypeStructureNode GetSimpleTypeStructure(XmlSchemaSimpleTypeContent content) { var simpleTypeStructureBuilder = new SimpleTypeStructureBuilder(SchemaSet); simpleTypeStructureBuilder.Traverse(content); return(simpleTypeStructureBuilder.GetRoot()); }
protected virtual void Visit(XmlSchemaSimpleTypeContent simpleTypeContent) { XmlSchemaSimpleTypeList list; XmlSchemaSimpleTypeRestriction restriction; XmlSchemaSimpleTypeUnion union; if (Casting.TryCast(simpleTypeContent, out list)) { Visit(list); } else if (Casting.TryCast(simpleTypeContent, out restriction)) { Visit(restriction); } else if (Casting.TryCast(simpleTypeContent, out union)) { Visit(union); } else { throw ExceptionBuilder.UnexpectedSchemaObjectType(simpleTypeContent); } }
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); } } } } }
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); } } } } }