private void ImportAccessorMapping(MemberMapping accessor, FieldModel model, SoapAttributes a, string ns, XmlSchemaForm form, RecursionLimiter limiter)
{
Type accessorType = model.FieldType;
string accessorName = model.Name;
accessor.TypeDesc = _typeScope.GetTypeDesc(accessorType);
if (accessor.TypeDesc.IsVoid)
{
throw new InvalidOperationException(SR.XmlInvalidVoid);
}
SoapAttributeFlags flags = a.GetSoapFlags();
if ((flags & SoapAttributeFlags.Attribute) == SoapAttributeFlags.Attribute)
{
if (!accessor.TypeDesc.IsPrimitive && !accessor.TypeDesc.IsEnum)
{
throw new InvalidOperationException(SR.Format(SR.XmlIllegalSoapAttribute, accessorName, accessor.TypeDesc.FullName));
}
if ((flags & SoapAttributeFlags.Attribute) != flags)
{
throw new InvalidOperationException(SR.XmlInvalidElementAttribute);
}
AttributeAccessor attribute = new AttributeAccessor();
attribute.Name = Accessor.EscapeQName(a.SoapAttribute == null || a.SoapAttribute.AttributeName.Length == 0 ? accessorName : a.SoapAttribute.AttributeName);
attribute.Namespace = a.SoapAttribute == null || a.SoapAttribute.Namespace == null ? ns : a.SoapAttribute.Namespace;
attribute.Form = XmlSchemaForm.Qualified; // attributes are always qualified since they're only used for encoded soap headers
attribute.Mapping = ImportTypeMapping(_modelScope.GetTypeModel(accessorType), (a.SoapAttribute == null ? String.Empty : a.SoapAttribute.DataType), limiter);
attribute.Default = GetDefaultValue(model.FieldTypeDesc, a);
accessor.Attribute = attribute;
accessor.Elements = new ElementAccessor[0];
}
else
{
if ((flags & SoapAttributeFlags.Element) != flags)
{
throw new InvalidOperationException(SR.XmlInvalidElementAttribute);
}
ElementAccessor element = new ElementAccessor();
element.IsSoap = true;
element.Name = XmlConvert.EncodeLocalName(a.SoapElement == null || a.SoapElement.ElementName.Length == 0 ? accessorName : a.SoapElement.ElementName);
element.Namespace = ns;
element.Form = form;
element.Mapping = ImportTypeMapping(_modelScope.GetTypeModel(accessorType), (a.SoapElement == null ? String.Empty : a.SoapElement.DataType), limiter);
if (a.SoapElement != null)
{
element.IsNullable = a.SoapElement.IsNullable;
}
accessor.Elements = new ElementAccessor[] { element };
}
}
private ConstantMapping ImportConstantMapping(ConstantModel model)
{
SoapAttributes a = GetAttributes(model.FieldInfo);
if (a.SoapIgnore)
{
return(null);
}
if ((a.GetSoapFlags() & ~SoapAttributeFlags.Enum) != 0)
{
throw new InvalidOperationException(SR.XmlInvalidEnumAttribute);
}
if (a.SoapEnum == null)
{
a.SoapEnum = new SoapEnumAttribute();
}
ConstantMapping constant = new ConstantMapping();
constant.XmlName = a.SoapEnum.Name.Length == 0 ? model.Name : a.SoapEnum.Name;
constant.Name = model.Name;
constant.Value = model.Value;
return(constant);
}
private TypeMapping ImportTypeMapping(TypeModel model, string dataType, RecursionLimiter limiter)
{
if (dataType.Length > 0)
{
if (!model.TypeDesc.IsPrimitive)
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidDataTypeUsage, dataType, "SoapElementAttribute.DataType"));
}
TypeDesc td = _typeScope.GetTypeDesc(dataType, XmlSchema.Namespace);
if (td == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidXsdDataType, dataType, "SoapElementAttribute.DataType", new XmlQualifiedName(dataType, XmlSchema.Namespace).ToString()));
}
if (model.TypeDesc.FullName != td.FullName)
{
throw new InvalidOperationException(SR.Format(SR.XmlDataTypeMismatch, dataType, "SoapElementAttribute.DataType", model.TypeDesc.FullName));
}
}
SoapAttributes a = GetAttributes(model.Type);
if ((a.GetSoapFlags() & ~SoapAttributeFlags.Type) != 0)
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidTypeAttributes, model.Type.FullName));
}
switch (model.TypeDesc.Kind)
{
case TypeKind.Enum:
return(ImportEnumMapping((EnumModel)model));
case TypeKind.Primitive:
return(ImportPrimitiveMapping((PrimitiveModel)model, dataType));
case TypeKind.Array:
case TypeKind.Collection:
case TypeKind.Enumerable:
return(ImportArrayLikeMapping((ArrayModel)model, limiter));
case TypeKind.Root:
case TypeKind.Class:
case TypeKind.Struct:
if (model.TypeDesc.IsOptionalValue)
{
TypeDesc baseTypeDesc = model.TypeDesc.BaseTypeDesc;
SoapAttributes baseAttributes = GetAttributes(baseTypeDesc.Type);
string typeNs = _defaultNs;
if (baseAttributes.SoapType != null && baseAttributes.SoapType.Namespace != null)
{
typeNs = baseAttributes.SoapType.Namespace;
}
TypeDesc valueTypeDesc = string.IsNullOrEmpty(dataType) ? model.TypeDesc.BaseTypeDesc : _typeScope.GetTypeDesc(dataType, XmlSchema.Namespace);
string xsdTypeName = string.IsNullOrEmpty(dataType) ? model.TypeDesc.BaseTypeDesc.Name : dataType;
TypeMapping baseMapping = GetTypeMapping(xsdTypeName, typeNs, valueTypeDesc);
if (baseMapping == null)
{
baseMapping = ImportTypeMapping(_modelScope.GetTypeModel(baseTypeDesc.Type), dataType, limiter);
}
return(CreateNullableMapping(baseMapping, model.TypeDesc.Type));
}
else
{
return(ImportStructLikeMapping((StructModel)model, limiter));
}
default:
throw new NotSupportedException(SR.Format(SR.XmlUnsupportedSoapTypeKind, model.TypeDesc.FullName));
}
}