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);
}
XmlTypeMapping ImportEnumMapping(Type type, string defaultNamespace)
{
TypeData typeData = TypeTranslator.GetTypeData(type);
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;
string [] names = Enum.GetNames(type);
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember[names.Length];
for (int n = 0; n < names.Length; n++)
{
MemberInfo[] mem = type.GetMember(names[n]);
string xmlName = names[n];
object[] atts = mem[0].GetCustomAttributes(typeof(SoapEnumAttribute), false);
if (atts.Length > 0)
{
xmlName = ((SoapEnumAttribute)atts[0]).Name;
}
members[n] = new EnumMap.EnumMapMember(xmlName, names[n]);
}
bool isFlags = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
map.ObjectMap = new EnumMap(members, isFlags);
ImportTypeMapping(typeof(object), defaultNamespace).DerivedTypes.Add(map);
return(map);
}
protected override void GenerateEnumItem(CodeMemberField codeField, EnumMap.EnumMapMember emem)
{
if (emem.EnumName != emem.XmlName)
{
CodeAttributeDeclaration xatt = new CodeAttributeDeclaration("System.Xml.Serialization.SoapEnum");
xatt.Arguments.Add(GetArg("Name", emem.XmlName));
AddCustomAttribute(codeField, xatt, true);
}
}
public EnumMap(EnumMap.EnumMapMember[] members, bool isFlags)
{
this._members = members;
this._isFlags = isFlags;
this._enumNames = new string[this._members.Length];
this._xmlNames = new string[this._members.Length];
this._values = new long[this._members.Length];
for (int i = 0; i < this._members.Length; i++)
{
EnumMap.EnumMapMember enumMapMember = this._members[i];
this._enumNames[i] = enumMapMember.EnumName;
this._xmlNames[i] = enumMapMember.XmlName;
this._values[i] = enumMapMember.Value;
}
}
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 ImportClassSimpleType (XmlQualifiedName typeQName, XmlSchemaSimpleType stype, XmlQualifiedName root)
{
if (CanBeEnum (stype))
{
// Create an enum map
CodeIdentifiers codeIdents = new CodeIdentifiers ();
XmlTypeMapping enumMap = CreateTypeMapping (typeQName, SchemaTypes.Enum, root);
enumMap.Documentation = GetDocumentation (stype);
bool isFlags = false;
if (stype.Content is XmlSchemaSimpleTypeList) {
stype = ((XmlSchemaSimpleTypeList)stype.Content).ItemType;
isFlags = true;
}
XmlSchemaSimpleTypeRestriction rest = (XmlSchemaSimpleTypeRestriction)stype.Content;
codeIdents.AddReserved (enumMap.TypeData.TypeName);
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [rest.Facets.Count];
for (int n=0; n<rest.Facets.Count; n++)
{
XmlSchemaEnumerationFacet enu = (XmlSchemaEnumerationFacet) rest.Facets[n];
string enumName = codeIdents.AddUnique(CodeIdentifier.MakeValid (enu.Value), enu);
members [n] = new EnumMap.EnumMapMember (enu.Value, enumName);
members [n].Documentation = GetDocumentation (enu);
}
enumMap.ObjectMap = new EnumMap (members, isFlags);
enumMap.IsSimpleType = true;
return enumMap;
}
if (stype.Content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList slist = (XmlSchemaSimpleTypeList)stype.Content;
TypeData arrayTypeData = FindBuiltInType (slist.ItemTypeName, stype);
ListMap listMap = new ListMap ();
listMap.ItemInfo = new XmlTypeMapElementInfoList ();
listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false, XmlSchemaForm.None, -1));
XmlTypeMapping map = CreateArrayTypeMapping (typeQName, arrayTypeData);
map.ObjectMap = listMap;
map.IsSimpleType = true;
return map;
}
// It is an extension of a primitive or known type
TypeData typeData = FindBuiltInType (typeQName, stype);
XmlTypeMapping rmap = GetTypeMapping (typeData);
// The resulting map must be a simple type. It needs to be explicitely set for arrays
rmap.IsSimpleType = true;
return rmap;
}
void ImportChoiceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaChoice choice, CodeIdentifiers classIds, bool multiValue)
{
XmlTypeMapElementInfoList choices = new XmlTypeMapElementInfoList ();
multiValue = ImportChoices (typeQName, null, choices, choice.Items) || multiValue;
if (choices.Count == 0) return;
if (choice.MaxOccurs > 1) multiValue = true;
XmlTypeMapMemberElement member;
if (multiValue)
{
member = new XmlTypeMapMemberFlatList ();
member.Name = classIds.AddUnique ("Items", member);
ListMap listMap = new ListMap ();
listMap.ItemInfo = choices;
((XmlTypeMapMemberFlatList)member).ListMap = listMap;
}
else
{
member = new XmlTypeMapMemberElement ();
member.Name = classIds.AddUnique ("Item", member);
}
// If all choices have the same type, use that type for the member.
// If not use System.Object.
// If there are at least two choices with the same type, use a choice
// identifier attribute
TypeData typeData = null;
bool twoEqual = false;
bool allEqual = true;
Hashtable types = new Hashtable ();
for (int n = choices.Count - 1; n >= 0; n--)
{
XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) choices [n];
// In some complex schemas, we may end up with several options
// with the same name. It is better to ignore the extra options
// than to crash. It's the best we can do, and btw it works
// better than in MS.NET.
if (cmap.GetElement (einfo.ElementName, einfo.Namespace, einfo.ExplicitOrder) != null ||
choices.IndexOfElement (einfo.ElementName, einfo.Namespace) != n)
{
choices.RemoveAt (n);
continue;
}
if (types.ContainsKey (einfo.TypeData)) twoEqual = true;
else types.Add (einfo.TypeData, einfo);
TypeData choiceType = einfo.TypeData;
if (choiceType.SchemaType == SchemaTypes.Class)
{
// When comparing class types, use the most generic class in the
// inheritance hierarchy
XmlTypeMapping choiceMap = GetTypeMapping (choiceType);
BuildPendingMap (choiceMap);
while (choiceMap.BaseMap != null) {
choiceMap = choiceMap.BaseMap;
BuildPendingMap (choiceMap);
choiceType = choiceMap.TypeData;
}
}
if (typeData == null) typeData = choiceType;
else if (typeData != choiceType) allEqual = false;
}
if (!allEqual)
typeData = TypeTranslator.GetTypeData (typeof(object));
if (twoEqual)
{
// Create the choice member
XmlTypeMapMemberElement choiceMember = new XmlTypeMapMemberElement ();
choiceMember.Ignore = true;
choiceMember.Name = classIds.AddUnique (member.Name + "ElementName", choiceMember);
member.ChoiceMember = choiceMember.Name;
// Create the choice enum
XmlTypeMapping enumMap = CreateTypeMapping (new XmlQualifiedName (member.Name + "ChoiceType", typeQName.Namespace), SchemaTypes.Enum, null);
enumMap.IncludeInSchema = false;
CodeIdentifiers codeIdents = new CodeIdentifiers ();
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember [choices.Count];
for (int n=0; n<choices.Count; n++)
{
XmlTypeMapElementInfo it =(XmlTypeMapElementInfo) choices[n];
bool extraNs = (it.Namespace != null && it.Namespace != "" && it.Namespace != typeQName.Namespace);
string xmlName = extraNs ? it.Namespace + ":" + it.ElementName : it.ElementName;
string enumName = codeIdents.AddUnique (CodeIdentifier.MakeValid (it.ElementName), it);
members [n] = new EnumMap.EnumMapMember (xmlName, enumName);
}
enumMap.ObjectMap = new EnumMap (members, false);
choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData;
choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None, -1));
cmap.AddMember (choiceMember);
}
if (typeData == null)
return;
if (multiValue)
typeData = typeData.ListTypeData;
member.ElementInfo = choices;
member.Documentation = GetDocumentation (choice);
member.TypeData = typeData;
cmap.AddMember (member);
}
protected virtual void GenerateEnumItem(CodeMemberField codeField, EnumMap.EnumMapMember emem)
{
}
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 ImportEnumMapping (Type type, string defaultNamespace)
{
TypeData typeData = TypeTranslator.GetTypeData (type);
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;
string [] names = Enum.GetNames (type);
EnumMap.EnumMapMember[] members = new EnumMap.EnumMapMember[names.Length];
for (int n=0; n<names.Length; n++)
{
MemberInfo[] mem = type.GetMember (names[n]);
string xmlName = names[n];
object[] atts = mem[0].GetCustomAttributes (typeof(SoapEnumAttribute), false);
if (atts.Length > 0) xmlName = ((SoapEnumAttribute)atts[0]).Name;
members[n] = new EnumMap.EnumMapMember (xmlName, names[n]);
}
bool isFlags = type.GetCustomAttributes (typeof(FlagsAttribute),false).Length > 0;
map.ObjectMap = new EnumMap (members, isFlags);
ImportTypeMapping (typeof(object), defaultNamespace).DerivedTypes.Add (map);
return map;
}
