|
static private ParseWsdlArrayType ( string type, string &dims, |
||
| type | string | |
| dims | string | |
| parent | ||
| return | ||
protected void WriteXmlAttribute(XmlNode node, object container)
{
XmlAttribute attr = node as XmlAttribute;
if (attr == null)
{
throw new InvalidOperationException(SR.XmlNeedAttributeHere);
}
if (attr.Value != null)
{
if (attr.NamespaceURI == Wsdl.Namespace && attr.LocalName == Wsdl.ArrayType)
{
string dims;
XmlQualifiedName qname = TypeScope.ParseWsdlArrayType(attr.Value, out dims, (container is XmlSchemaObject) ? (XmlSchemaObject)container : null);
string value = FromXmlQualifiedName(qname, true) + dims;
//<xsd:attribute xmlns:q3="s0" wsdl:arrayType="q3:FoosBase[]" xmlns:q4="http://schemas.xmlsoap.org/soap/encoding/" ref="q4:arrayType" />
WriteAttribute(Wsdl.ArrayType, Wsdl.Namespace, value);
}
else
{
WriteAttribute(attr.Name, attr.NamespaceURI, attr.Value);
}
}
}
private ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns)
{
ArrayMapping arrayMapping;
if (type.Name == Soap.Array && ns == Soap.Encoding)
{
arrayMapping = new ArrayMapping();
TypeMapping mapping = GetRootMapping();
ElementAccessor itemAccessor = new ElementAccessor();
itemAccessor.IsSoap = true;
itemAccessor.Name = Soap.UrType;
itemAccessor.Namespace = ns;
itemAccessor.Mapping = mapping;
itemAccessor.IsNullable = true;
itemAccessor.Form = XmlSchemaForm.None;
arrayMapping.Elements = new ElementAccessor[] { itemAccessor };
arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc();
arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName);
return(arrayMapping);
}
if (!(type.DerivedFrom.Name == Soap.Array && type.DerivedFrom.Namespace == Soap.Encoding))
{
return(null);
}
// the type should be a XmlSchemaComplexType
XmlSchemaContentModel model = ((XmlSchemaComplexType)type).ContentModel;
// the Content should be an restriction
if (!(model.Content is XmlSchemaComplexContentRestriction))
{
return(null);
}
arrayMapping = new ArrayMapping();
XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)model.Content;
for (int i = 0; i < restriction.Attributes.Count; i++)
{
XmlSchemaAttribute attribute = restriction.Attributes[i] as XmlSchemaAttribute;
if (attribute != null && attribute.RefName.Name == Soap.ArrayType && attribute.RefName.Namespace == Soap.Encoding)
{
// read the value of the wsdl:arrayType attribute
string arrayType = null;
if (attribute.UnhandledAttributes != null)
{
foreach (XmlAttribute a in attribute.UnhandledAttributes)
{
if (a.LocalName == Wsdl.ArrayType && a.NamespaceURI == Wsdl.Namespace)
{
arrayType = a.Value;
break;
}
}
}
if (arrayType != null)
{
string dims;
XmlQualifiedName typeName = TypeScope.ParseWsdlArrayType(arrayType, out dims, attribute);
TypeMapping mapping;
TypeDesc td = Scope.GetTypeDesc(typeName.Name, typeName.Namespace);
if (td != null && td.IsPrimitive)
{
mapping = new PrimitiveMapping();
mapping.TypeDesc = td;
mapping.TypeName = td.DataType.Name;
}
else
{
mapping = ImportType(typeName, false);
}
ElementAccessor itemAccessor = new ElementAccessor();
itemAccessor.IsSoap = true;
itemAccessor.Name = typeName.Name;
itemAccessor.Namespace = ns;
itemAccessor.Mapping = mapping;
itemAccessor.IsNullable = true;
itemAccessor.Form = XmlSchemaForm.None;
arrayMapping.Elements = new ElementAccessor[] { itemAccessor };
arrayMapping.TypeDesc = itemAccessor.Mapping.TypeDesc.CreateArrayTypeDesc();
arrayMapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(itemAccessor.Mapping.TypeName);
return(arrayMapping);
}
}
}
XmlSchemaParticle particle = restriction.Particle;
if (particle is XmlSchemaAll || particle is XmlSchemaSequence)
{
XmlSchemaGroupBase group = (XmlSchemaGroupBase)particle;
if (group.Items.Count != 1 || !(group.Items[0] is XmlSchemaElement))
{
return(null);
}
XmlSchemaElement itemElement = (XmlSchemaElement)group.Items[0];
if (!itemElement.IsMultipleOccurrence)
{
return(null);
}
ElementAccessor itemAccessor = ImportElement(itemElement, ns);
arrayMapping.Elements = new ElementAccessor[] { itemAccessor };
arrayMapping.TypeDesc = ((TypeMapping)itemAccessor.Mapping).TypeDesc.CreateArrayTypeDesc();
}
else
{
return(null);
}
return(arrayMapping);
}
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);
}
}
}
}
}
private ArrayMapping ImportArrayMapping(XmlSchemaType type, string ns)
{
ArrayMapping mapping;
if ((type.Name == "Array") && (ns == "http://schemas.xmlsoap.org/soap/encoding/"))
{
mapping = new ArrayMapping();
TypeMapping rootMapping = base.GetRootMapping();
ElementAccessor accessor = new ElementAccessor {
IsSoap = true,
Name = "anyType",
Namespace = ns,
Mapping = rootMapping,
IsNullable = true,
Form = XmlSchemaForm.None
};
mapping.Elements = new ElementAccessor[] { accessor };
mapping.TypeDesc = accessor.Mapping.TypeDesc.CreateArrayTypeDesc();
mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor.Mapping.TypeName);
return(mapping);
}
if ((type.DerivedFrom.Name != "Array") || (type.DerivedFrom.Namespace != "http://schemas.xmlsoap.org/soap/encoding/"))
{
return(null);
}
XmlSchemaContentModel contentModel = ((XmlSchemaComplexType)type).ContentModel;
if (!(contentModel.Content is XmlSchemaComplexContentRestriction))
{
return(null);
}
mapping = new ArrayMapping();
XmlSchemaComplexContentRestriction content = (XmlSchemaComplexContentRestriction)contentModel.Content;
for (int i = 0; i < content.Attributes.Count; i++)
{
XmlSchemaAttribute parent = content.Attributes[i] as XmlSchemaAttribute;
if (((parent != null) && (parent.RefName.Name == "arrayType")) && (parent.RefName.Namespace == "http://schemas.xmlsoap.org/soap/encoding/"))
{
string str = null;
if (parent.UnhandledAttributes != null)
{
foreach (XmlAttribute attribute2 in parent.UnhandledAttributes)
{
if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/"))
{
str = attribute2.Value;
break;
}
}
}
if (str != null)
{
string str2;
TypeMapping mapping3;
XmlQualifiedName name = TypeScope.ParseWsdlArrayType(str, out str2, parent);
TypeDesc typeDesc = base.Scope.GetTypeDesc(name.Name, name.Namespace);
if ((typeDesc != null) && typeDesc.IsPrimitive)
{
mapping3 = new PrimitiveMapping {
TypeDesc = typeDesc,
TypeName = typeDesc.DataType.Name
};
}
else
{
mapping3 = this.ImportType(name, false);
}
ElementAccessor accessor2 = new ElementAccessor {
IsSoap = true,
Name = name.Name,
Namespace = ns,
Mapping = mapping3,
IsNullable = true,
Form = XmlSchemaForm.None
};
mapping.Elements = new ElementAccessor[] { accessor2 };
mapping.TypeDesc = accessor2.Mapping.TypeDesc.CreateArrayTypeDesc();
mapping.TypeName = "ArrayOf" + CodeIdentifier.MakePascal(accessor2.Mapping.TypeName);
return(mapping);
}
}
}
XmlSchemaParticle particle = content.Particle;
if (!(particle is XmlSchemaAll) && !(particle is XmlSchemaSequence))
{
return(null);
}
XmlSchemaGroupBase base2 = (XmlSchemaGroupBase)particle;
if ((base2.Items.Count != 1) || !(base2.Items[0] is XmlSchemaElement))
{
return(null);
}
XmlSchemaElement element = (XmlSchemaElement)base2.Items[0];
if (!element.IsMultipleOccurrence)
{
return(null);
}
ElementAccessor accessor3 = this.ImportElement(element, ns);
mapping.Elements = new ElementAccessor[] { accessor3 };
mapping.TypeDesc = accessor3.Mapping.TypeDesc.CreateArrayTypeDesc();
return(mapping);
}
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);
}
}
}
}
}
}