private XmlTypeMapping ImportEnumMapping(TypeData typeData, string defaultNamespace)
{
Type type = typeData.Type;
XmlTypeMapping xmlTypeMapping = this.helper.GetRegisteredClrType(type, this.GetTypeNamespace(typeData, defaultNamespace));
if (xmlTypeMapping != null)
{
return(xmlTypeMapping);
}
ReflectionHelper.CheckSerializableType(type, false);
xmlTypeMapping = this.CreateTypeMapping(typeData, null, defaultNamespace);
this.helper.RegisterClrType(xmlTypeMapping, type, xmlTypeMapping.Namespace);
xmlTypeMapping.MultiReferenceType = true;
string[] names = Enum.GetNames(type);
EnumMap.EnumMapMember[] array = new EnumMap.EnumMapMember[names.Length];
for (int i = 0; i < names.Length; i++)
{
FieldInfo field = type.GetField(names[i]);
string name = names[i];
object[] customAttributes = field.GetCustomAttributes(typeof(SoapEnumAttribute), false);
if (customAttributes.Length > 0)
{
name = ((SoapEnumAttribute)customAttributes[0]).Name;
}
long value = ((IConvertible)field.GetValue(null)).ToInt64(CultureInfo.InvariantCulture);
array[i] = new EnumMap.EnumMapMember(XmlConvert.EncodeLocalName(name), names[i], value);
}
bool isFlags = type.IsDefined(typeof(FlagsAttribute), false);
xmlTypeMapping.ObjectMap = new EnumMap(array, isFlags);
this.ImportTypeMapping(typeof(object), defaultNamespace).DerivedTypes.Add(xmlTypeMapping);
return(xmlTypeMapping);
}
private XmlTypeMapping ImportClassMapping(TypeData typeData, string defaultNamespace)
{
Type type = typeData.Type;
if (type.IsValueType)
{
throw this.CreateStructException(type);
}
if (type == typeof(object))
{
defaultNamespace = "http://www.w3.org/2001/XMLSchema";
}
ReflectionHelper.CheckSerializableType(type, false);
XmlTypeMapping xmlTypeMapping = this.helper.GetRegisteredClrType(type, this.GetTypeNamespace(typeData, defaultNamespace));
if (xmlTypeMapping != null)
{
return(xmlTypeMapping);
}
xmlTypeMapping = this.CreateTypeMapping(typeData, null, defaultNamespace);
this.helper.RegisterClrType(xmlTypeMapping, type, xmlTypeMapping.Namespace);
xmlTypeMapping.MultiReferenceType = true;
ClassMap classMap = new ClassMap();
xmlTypeMapping.ObjectMap = classMap;
ICollection reflectionMembers = this.GetReflectionMembers(type);
foreach (object obj in reflectionMembers)
{
XmlReflectionMember xmlReflectionMember = (XmlReflectionMember)obj;
if (!xmlReflectionMember.SoapAttributes.SoapIgnore)
{
classMap.AddMember(this.CreateMapMember(xmlReflectionMember, defaultNamespace));
}
}
SoapIncludeAttribute[] array = (SoapIncludeAttribute[])type.GetCustomAttributes(typeof(SoapIncludeAttribute), false);
for (int i = 0; i < array.Length; i++)
{
Type type2 = array[i].Type;
this.ImportTypeMapping(type2);
}
if (type == typeof(object) && this.includedTypes != null)
{
foreach (object obj2 in this.includedTypes)
{
Type type3 = (Type)obj2;
xmlTypeMapping.DerivedTypes.Add(this.ImportTypeMapping(type3));
}
}
if (type.BaseType != null)
{
XmlTypeMapping xmlTypeMapping2 = this.ImportClassMapping(type.BaseType, defaultNamespace);
if (type.BaseType != typeof(object))
{
xmlTypeMapping.BaseMap = xmlTypeMapping2;
}
this.RegisterDerivedMap(xmlTypeMapping2, xmlTypeMapping);
}
return(xmlTypeMapping);
}
XmlTypeMapping ImportEnumMapping(TypeData typeData, string defaultNamespace)
{
Type type = typeData.Type;
XmlTypeMapping map = helper.GetRegisteredClrType(type, GetTypeNamespace(typeData, defaultNamespace));
if (map != null)
{
return(map);
}
ReflectionHelper.CheckSerializableType(type, false);
map = CreateTypeMapping(typeData, null, defaultNamespace);
helper.RegisterClrType(map, type, map.Namespace);
map.MultiReferenceType = true;
string [] names = Enum.GetNames(type);
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember[names.Length];
for (int n = 0; n < names.Length; n++)
{
FieldInfo field = type.GetField(names[n]);
string xmlName = names[n];
object[] atts = field.GetCustomAttributes(typeof(SoapEnumAttribute), false);
if (atts.Length > 0)
{
xmlName = ((SoapEnumAttribute)atts[0]).Name;
}
long value = ((IConvertible)field.GetValue(null)).ToInt64(CultureInfo.InvariantCulture);
members[n] = new EnumMap.EnumMapMember(XmlConvert.EncodeLocalName(xmlName), names[n], value);
}
bool isFlags = type.IsDefined(typeof(FlagsAttribute), false);
map.ObjectMap = new EnumMap(members, isFlags);
ImportTypeMapping(typeof(object), defaultNamespace).DerivedTypes.Add(map);
return(map);
}
XmlTypeMapping ImportListMapping(Type type, XmlRootAttribute root, string defaultNamespace, XmlAttributes atts, int nestingLevel)
{
TypeData typeData = TypeTranslator.GetTypeData(type);
ListMap obmap = new ListMap();
if (!allowPrivateTypes)
{
ReflectionHelper.CheckSerializableType(type);
}
if (atts == null)
{
atts = new XmlAttributes();
}
Type itemType = typeData.ListItemType;
// warning: byte[][] should not be considered multiarray
bool isMultiArray = (type.IsArray && (TypeTranslator.GetTypeData(itemType).SchemaType == SchemaTypes.Array) && itemType.IsArray);
XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList();
foreach (XmlArrayItemAttribute att in atts.XmlArrayItems)
{
if (att.NestingLevel != nestingLevel)
{
continue;
}
Type elemType = (att.Type != null) ? att.Type : itemType;
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(null, TypeTranslator.GetTypeData(elemType, att.DataType));
elem.Namespace = att.Namespace != null ? att.Namespace : defaultNamespace;
if (elem.Namespace == null)
{
elem.Namespace = "";
}
elem.Form = att.Form;
elem.IsNullable = att.IsNullable && CanBeNull(elem.TypeData);
elem.NestingLevel = att.NestingLevel;
if (isMultiArray)
{
elem.MappedType = ImportListMapping(elemType, null, elem.Namespace, atts, nestingLevel + 1);
}
else if (elem.TypeData.IsComplexType)
{
elem.MappedType = ImportTypeMapping(elemType, null, elem.Namespace);
}
if (att.ElementName != null)
{
elem.ElementName = att.ElementName;
}
else if (elem.MappedType != null)
{
elem.ElementName = elem.MappedType.ElementName;
}
else
{
elem.ElementName = TypeTranslator.GetTypeData(elemType).XmlType;
}
list.Add(elem);
}
if (list.Count == 0)
{
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(null, TypeTranslator.GetTypeData(itemType));
if (isMultiArray)
{
elem.MappedType = ImportListMapping(itemType, null, defaultNamespace, atts, nestingLevel + 1);
}
else if (elem.TypeData.IsComplexType)
{
elem.MappedType = ImportTypeMapping(itemType, null, defaultNamespace);
}
if (elem.MappedType != null)
{
elem.ElementName = elem.MappedType.XmlType;
}
else
{
elem.ElementName = TypeTranslator.GetTypeData(itemType).XmlType;
}
elem.Namespace = (defaultNamespace != null) ? defaultNamespace : "";
elem.IsNullable = CanBeNull(elem.TypeData);
list.Add(elem);
}
obmap.ItemInfo = list;
// If there can be different element names (types) in the array, then its name cannot
// be "ArrayOfXXX" it must be something like ArrayOfChoiceNNN
string baseName;
if (list.Count > 1)
{
baseName = "ArrayOfChoice" + (arrayChoiceCount++);
}
else
{
XmlTypeMapElementInfo elem = ((XmlTypeMapElementInfo)list[0]);
if (elem.MappedType != null)
{
baseName = TypeTranslator.GetArrayName(elem.MappedType.XmlType);
}
else
{
baseName = TypeTranslator.GetArrayName(elem.ElementName);
}
}
// Avoid name colisions
int nameCount = 1;
string name = baseName;
do
{
XmlTypeMapping foundMap = helper.GetRegisteredSchemaType(name, defaultNamespace);
if (foundMap == null)
{
nameCount = -1;
}
else if (obmap.Equals(foundMap.ObjectMap) && typeData.Type == foundMap.TypeData.Type)
{
return(foundMap);
}
else
{
name = baseName + (nameCount++);
}
}while (nameCount != -1);
XmlTypeMapping map = CreateTypeMapping(typeData, root, name, defaultNamespace);
map.ObjectMap = obmap;
// Register any of the including types as a derived class of object
XmlIncludeAttribute[] includes = (XmlIncludeAttribute[])type.GetCustomAttributes(typeof(XmlIncludeAttribute), false);
XmlTypeMapping objectMapping = ImportTypeMapping(typeof(object));
for (int i = 0; i < includes.Length; i++)
{
Type includedType = includes[i].Type;
objectMapping.DerivedTypes.Add(ImportTypeMapping(includedType, null, defaultNamespace));
}
// Register this map as a derived class of object
helper.RegisterSchemaType(map, name, defaultNamespace);
ImportTypeMapping(typeof(object)).DerivedTypes.Add(map);
return(map);
}
XmlTypeMapping ImportClassMapping(Type type, XmlRootAttribute root, string defaultNamespace)
{
TypeData typeData = TypeTranslator.GetTypeData(type);
XmlTypeMapping map = helper.GetRegisteredClrType(type, GetTypeNamespace(typeData, root, defaultNamespace));
if (map != null)
{
return(map);
}
if (!allowPrivateTypes)
{
ReflectionHelper.CheckSerializableType(type);
}
map = CreateTypeMapping(typeData, root, null, defaultNamespace);
helper.RegisterClrType(map, type, map.XmlTypeNamespace);
helper.RegisterSchemaType(map, map.XmlType, map.XmlTypeNamespace);
// Import members
ClassMap classMap = new ClassMap();
map.ObjectMap = classMap;
// try
// {
ICollection members = GetReflectionMembers(type);
foreach (XmlReflectionMember rmember in members)
{
if (rmember.XmlAttributes.XmlIgnore)
{
continue;
}
XmlTypeMapMember mem = CreateMapMember(rmember, map.XmlTypeNamespace);
mem.CheckOptionalValueType(type);
classMap.AddMember(mem);
}
// }
// catch (Exception ex) {
// throw helper.CreateError (map, ex.Message);
// }
ImportIncludedTypes(type, defaultNamespace);
// Import extra classes
if (type == typeof(object) && includedTypes != null)
{
foreach (Type intype in includedTypes)
{
map.DerivedTypes.Add(ImportTypeMapping(intype, defaultNamespace));
}
}
// Register inheritance relations
if (type.BaseType != null)
{
XmlTypeMapping bmap = ImportClassMapping(type.BaseType, root, defaultNamespace);
if (type.BaseType != typeof(object))
{
map.BaseMap = bmap;
classMap.SetCanBeSimpleType(false);
}
// At this point, derived classes of this map must be already registered
RegisterDerivedMap(bmap, map);
if (((ClassMap)bmap.ObjectMap).HasSimpleContent && classMap.ElementMembers != null && classMap.ElementMembers.Count != 1)
{
throw new InvalidOperationException(String.Format(errSimple, map.TypeData.TypeName, map.BaseMap.TypeData.TypeName));
}
}
if (classMap.XmlTextCollector != null && !classMap.HasSimpleContent)
{
XmlTypeMapMember mem = classMap.XmlTextCollector;
if (mem.TypeData.Type != typeof(string) &&
mem.TypeData.Type != typeof(string[]) &&
mem.TypeData.Type != typeof(object[]) &&
mem.TypeData.Type != typeof(XmlNode[]))
{
throw new InvalidOperationException(String.Format(errSimple2, map.TypeData.TypeName, mem.Name, mem.TypeData.TypeName));
}
}
return(map);
}
XmlTypeMapping ImportClassMapping(TypeData typeData, string defaultNamespace)
{
Type type = typeData.Type;
if (type.IsValueType)
{
throw CreateStructException(type);
}
if (type == typeof(object))
{
defaultNamespace = XmlSchema.Namespace;
}
ReflectionHelper.CheckSerializableType(type, false);
XmlTypeMapping map = helper.GetRegisteredClrType(type, GetTypeNamespace(typeData, defaultNamespace));
if (map != null)
{
return(map);
}
map = CreateTypeMapping(typeData, null, defaultNamespace);
helper.RegisterClrType(map, type, map.Namespace);
map.MultiReferenceType = true;
ClassMap classMap = new ClassMap();
map.ObjectMap = classMap;
// Import members
ICollection members = GetReflectionMembers(type);
foreach (XmlReflectionMember rmember in members)
{
if (rmember.SoapAttributes.SoapIgnore)
{
continue;
}
classMap.AddMember(CreateMapMember(rmember, defaultNamespace));
}
// Import included classes
SoapIncludeAttribute[] includes = (SoapIncludeAttribute[])type.GetCustomAttributes(typeof(SoapIncludeAttribute), false);
for (int n = 0; n < includes.Length; n++)
{
Type includedType = includes[n].Type;
ImportTypeMapping(includedType);
}
if (type == typeof(object) && includedTypes != null)
{
foreach (Type intype in includedTypes)
{
map.DerivedTypes.Add(ImportTypeMapping(intype));
}
}
// Register inheritance relations
if (type.BaseType != null)
{
XmlTypeMapping bmap = ImportClassMapping(type.BaseType, defaultNamespace);
if (type.BaseType != typeof(object))
{
map.BaseMap = bmap;
}
// At this point, derived classes of this map must be already registered
RegisterDerivedMap(bmap, map);
}
return(map);
}