CodeTypeMember CreateFieldMember(CodeTypeDeclaration codeClass, TypeData type, string name)
{
return(CreateFieldMember(codeClass, GetDomType(type, false), name, System.DBNull.Value, null, null));
}
CodeTypeMember CreateFieldMember(CodeTypeDeclaration codeClass, CodeTypeReference type, string name, object defaultValue, TypeData defaultType, string documentation)
{
CodeMemberField codeField = null;
CodeTypeMember codeProp = null;
if ((options & CodeGenerationOptions.GenerateProperties) > 0)
{
string field = identifiers.AddUnique(CodeIdentifier.MakeCamel(name + "Field"), name);
codeField = new CodeMemberField(type, field);
codeField.Attributes = MemberAttributes.Private;
codeClass.Members.Add(codeField);
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = name;
prop.Type = type;
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeProp = prop;
prop.HasGet = prop.HasSet = true;
CodeExpression ce = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field);
prop.SetStatements.Add(new CodeAssignStatement(ce, new CodePropertySetValueReferenceExpression()));
prop.GetStatements.Add(new CodeMethodReturnStatement(ce));
}
else
{
codeField = new CodeMemberField(type, name);
codeField.Attributes = MemberAttributes.Public;
codeProp = codeField;
}
if (defaultValue != System.DBNull.Value)
{
GenerateDefaultAttribute(codeField, codeProp, defaultType, defaultValue);
}
AddComments(codeProp, documentation);
codeClass.Members.Add(codeProp);
return(codeProp);
}
protected override void GenerateArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
{
bool needsType = (listMap.ItemInfo.Count > 1) ||
(ainfo.TypeData.FullTypeName != type.FullTypeName && !listMap.IsMultiArray);
CodeAttributeDeclaration att = new CodeAttributeDeclaration("Mpd.Xml.Serialization.XmlArrayItem");
if (ainfo.ElementName != defaultName)
{
att.Arguments.Add(GetArg("ElementName", ainfo.ElementName));
}
if (ainfo.Namespace != defaultNamespace && ainfo.Namespace != XmlSchema.Namespace)
{
att.Arguments.Add(GetArg("Namespace", ainfo.Namespace));
}
if (needsType)
{
att.Arguments.Add(GetTypeArg("Type", ainfo.TypeData.FullTypeName));
}
if (!ainfo.IsNullable)
{
att.Arguments.Add(GetArg("IsNullable", false));
}
if (ainfo.Form == XmlSchemaForm.Unqualified)
{
att.Arguments.Add(MapCodeGenerator.GetEnumArg("Form", "System.Xml.Schema.XmlSchemaForm", ainfo.Form.ToString()));
}
if (att.Arguments.Count > 0 && nestingLevel > 0)
{
att.Arguments.Add(GetArg("NestingLevel", nestingLevel));
}
if (att.Arguments.Count > 0)
{
attributes.Add(att);
}
}
static TypeTranslator()
{
nameCache = new Hashtable();
primitiveArrayTypes = Hashtable.Synchronized(new Hashtable());
#if !TARGET_JVM
nameCache = Hashtable.Synchronized(nameCache);
#endif
// XSD Types with direct map to CLR types
nameCache.Add(typeof(bool), new TypeData(typeof(bool), "boolean", true));
nameCache.Add(typeof(short), new TypeData(typeof(short), "short", true));
nameCache.Add(typeof(ushort), new TypeData(typeof(ushort), "unsignedShort", true));
nameCache.Add(typeof(int), new TypeData(typeof(int), "int", true));
nameCache.Add(typeof(uint), new TypeData(typeof(uint), "unsignedInt", true));
nameCache.Add(typeof(long), new TypeData(typeof(long), "long", true));
nameCache.Add(typeof(ulong), new TypeData(typeof(ulong), "unsignedLong", true));
nameCache.Add(typeof(float), new TypeData(typeof(float), "float", true));
nameCache.Add(typeof(double), new TypeData(typeof(double), "double", true));
nameCache.Add(typeof(DateTime), new TypeData(typeof(DateTime), "dateTime", true)); // TODO: timeInstant, Xml date, xml time
nameCache.Add(typeof(decimal), new TypeData(typeof(decimal), "decimal", true));
nameCache.Add(typeof(XmlQualifiedName), new TypeData(typeof(XmlQualifiedName), "QName", true));
nameCache.Add(typeof(string), new TypeData(typeof(string), "string", true));
XmlSchemaPatternFacet guidFacet = new XmlSchemaPatternFacet();
guidFacet.Value = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
nameCache.Add(typeof(Guid), new TypeData(typeof(Guid), "guid", true, (TypeData)nameCache[typeof(string)], guidFacet));
nameCache.Add(typeof(byte), new TypeData(typeof(byte), "unsignedByte", true));
nameCache.Add(typeof(sbyte), new TypeData(typeof(sbyte), "byte", true));
nameCache.Add(typeof(char), new TypeData(typeof(char), "char", true, (TypeData)nameCache[typeof(ushort)], null));
nameCache.Add(typeof(object), new TypeData(typeof(object), "anyType", false));
nameCache.Add(typeof(byte[]), new TypeData(typeof(byte[]), "base64Binary", true));
nameCache.Add(typeof(XmlNode), new TypeData(typeof(XmlNode), "XmlNode", false));
nameCache.Add(typeof(XmlElement), new TypeData(typeof(XmlElement), "XmlElement", false));
primitiveTypes = new Hashtable();
ICollection types = nameCache.Values;
foreach (TypeData td in types)
{
primitiveTypes.Add(td.XmlType, td);
}
// Additional XSD types
primitiveTypes.Add("date", new TypeData(typeof(DateTime), "date", true)); // TODO: timeInstant
primitiveTypes.Add("time", new TypeData(typeof(DateTime), "time", true));
primitiveTypes.Add("timePeriod", new TypeData(typeof(DateTime), "timePeriod", true));
primitiveTypes.Add("gDay", new TypeData(typeof(string), "gDay", true));
primitiveTypes.Add("gMonthDay", new TypeData(typeof(string), "gMonthDay", true));
primitiveTypes.Add("gYear", new TypeData(typeof(string), "gYear", true));
primitiveTypes.Add("gYearMonth", new TypeData(typeof(string), "gYearMonth", true));
primitiveTypes.Add("month", new TypeData(typeof(DateTime), "month", true));
primitiveTypes.Add("NMTOKEN", new TypeData(typeof(string), "NMTOKEN", true));
primitiveTypes.Add("NMTOKENS", new TypeData(typeof(string), "NMTOKENS", true));
primitiveTypes.Add("Name", new TypeData(typeof(string), "Name", true));
primitiveTypes.Add("NCName", new TypeData(typeof(string), "NCName", true));
primitiveTypes.Add("language", new TypeData(typeof(string), "language", true));
primitiveTypes.Add("integer", new TypeData(typeof(string), "integer", true));
primitiveTypes.Add("positiveInteger", new TypeData(typeof(string), "positiveInteger", true));
primitiveTypes.Add("nonPositiveInteger", new TypeData(typeof(string), "nonPositiveInteger", true));
primitiveTypes.Add("negativeInteger", new TypeData(typeof(string), "negativeInteger", true));
primitiveTypes.Add("nonNegativeInteger", new TypeData(typeof(string), "nonNegativeInteger", true));
primitiveTypes.Add("ENTITIES", new TypeData(typeof(string), "ENTITIES", true));
primitiveTypes.Add("ENTITY", new TypeData(typeof(string), "ENTITY", true));
primitiveTypes.Add("hexBinary", new TypeData(typeof(byte[]), "hexBinary", true));
primitiveTypes.Add("ID", new TypeData(typeof(string), "ID", true));
primitiveTypes.Add("IDREF", new TypeData(typeof(string), "IDREF", true));
primitiveTypes.Add("IDREFS", new TypeData(typeof(string), "IDREFS", true));
primitiveTypes.Add("NOTATION", new TypeData(typeof(string), "NOTATION", true));
primitiveTypes.Add("token", new TypeData(typeof(string), "token", true));
primitiveTypes.Add("normalizedString", new TypeData(typeof(string), "normalizedString", true));
primitiveTypes.Add("anyURI", new TypeData(typeof(string), "anyURI", true));
primitiveTypes.Add("base64", new TypeData(typeof(byte[]), "base64", true));
primitiveTypes.Add("duration", new TypeData(typeof(string), "duration", true));
#if NET_2_0
nullableTypes = Hashtable.Synchronized(new Hashtable());
foreach (DictionaryEntry de in primitiveTypes)
{
TypeData td = (TypeData)de.Value;
TypeData ntd = new TypeData(td.Type, td.XmlType, true);
ntd.IsNullable = true;
nullableTypes.Add(de.Key, ntd);
}
#endif
}
protected virtual void GenerateArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
{
}
internal XmlSerializableMapping(string elementName, string ns, TypeData typeData, string xmlType, string xmlTypeNamespace)
: base(elementName, ns, typeData, xmlType, xmlTypeNamespace)
{
#if NET_2_0
XmlSchemaProviderAttribute schemaProvider = (XmlSchemaProviderAttribute)Attribute.GetCustomAttribute(typeData.Type, typeof(XmlSchemaProviderAttribute));
if (schemaProvider != null)
{
string method = schemaProvider.MethodName;
MethodInfo mi = typeData.Type.GetMethod(method, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
if (mi == null)
{
throw new InvalidOperationException(String.Format("Type '{0}' must implement public static method '{1}'", typeData.Type, method));
}
if (!typeof(XmlQualifiedName).IsAssignableFrom(mi.ReturnType) &&
// LAMESPEC: it is undocumented. (We don't have to tell users about it in the error message.)
// Also do not add such a silly compatibility test to assert that it does not raise an error.
!typeof(XmlSchemaComplexType).IsAssignableFrom(mi.ReturnType))
{
throw new InvalidOperationException(String.Format("Method '{0}' indicated by XmlSchemaProviderAttribute must have its return type as XmlQualifiedName", method));
}
XmlSchemaSet xs = new XmlSchemaSet();
object retVal = mi.Invoke(null, new object [] { xs });
_schemaTypeName = XmlQualifiedName.Empty;
if (retVal == null)
{
return;
}
if (retVal is XmlSchemaComplexType)
{
_schemaType = (XmlSchemaComplexType)retVal;
if (!_schemaType.QualifiedName.IsEmpty)
{
_schemaTypeName = _schemaType.QualifiedName;
}
else
{
_schemaTypeName = new XmlQualifiedName(xmlType, xmlTypeNamespace);
}
}
else if (retVal is XmlQualifiedName)
{
_schemaTypeName = (XmlQualifiedName)retVal;
}
else
{
throw new InvalidOperationException(
String.Format("Method {0}.{1}() specified by XmlSchemaProviderAttribute has invalid signature: return type must be compatible with System.Xml.XmlQualifiedName.", typeData.Type.Name, method));
}
// defaultNamespace at XmlReflectionImporter takes precedence for Namespace, but not for XsdTypeNamespace.
UpdateRoot(new XmlQualifiedName(_schemaTypeName.Name, Namespace ?? _schemaTypeName.Namespace));
XmlTypeNamespace = _schemaTypeName.Namespace;
XmlType = _schemaTypeName.Name;
if (!_schemaTypeName.IsEmpty && xs.Count > 0)
{
XmlSchema [] schemas = new XmlSchema [xs.Count];
xs.CopyTo(schemas, 0);
_schema = schemas [0];
}
return;
}
#endif
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(typeData.Type, true);
#if NET_2_0
try {
_schema = serializable.GetSchema();
} catch (Exception) {
// LAMESPEC: .NET has a bad exception catch and swallows it silently.
}
#else
_schema = serializable.GetSchema();
#endif
if (_schema != null)
{
if (_schema.Id == null || _schema.Id.Length == 0)
{
throw new InvalidOperationException("Schema Id is missing. The schema returned from " + typeData.Type.FullName + ".GetSchema() must have an Id.");
}
}
}
private XmlTypeMapMember CreateMapMember(XmlReflectionMember rmember, string defaultNamespace)
{
XmlTypeMapMember mapMember;
SoapAttributes atts = rmember.SoapAttributes;
TypeData typeData = TypeTranslator.GetTypeData(rmember.MemberType);
if (atts.SoapAttribute != null)
{
// An attribute
if (typeData.SchemaType != SchemaTypes.Enum && typeData.SchemaType != SchemaTypes.Primitive)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Cannot serialize member '{0}' of type {1}. " +
"SoapAttribute cannot be used to encode complex types.",
rmember.MemberName, typeData.FullTypeName));
}
if (atts.SoapElement != null)
{
throw new Exception("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member");
}
XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute();
if (atts.SoapAttribute.AttributeName.Length == 0)
{
mapAttribute.AttributeName = XmlConvert.EncodeLocalName(rmember.MemberName);
}
else
{
mapAttribute.AttributeName = XmlConvert.EncodeLocalName(atts.SoapAttribute.AttributeName);
}
mapAttribute.Namespace = (atts.SoapAttribute.Namespace != null) ? atts.SoapAttribute.Namespace : "";
if (typeData.IsComplexType)
{
mapAttribute.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace);
}
typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapAttribute.DataType);
mapMember = mapAttribute;
mapMember.DefaultValue = GetDefaultValue(typeData, atts.SoapDefaultValue);
}
else
{
if (typeData.SchemaType == SchemaTypes.Array)
{
mapMember = new XmlTypeMapMemberList();
}
else
{
mapMember = new XmlTypeMapMemberElement();
}
if (atts.SoapElement != null && atts.SoapElement.DataType.Length != 0)
{
typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.SoapElement.DataType);
}
// Creates an ElementInfo that identifies the element
XmlTypeMapElementInfoList infoList = new XmlTypeMapElementInfoList();
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo(mapMember, typeData);
elem.ElementName = XmlConvert.EncodeLocalName((atts.SoapElement != null && atts.SoapElement.ElementName.Length != 0) ? atts.SoapElement.ElementName : rmember.MemberName);
elem.Namespace = string.Empty;
elem.IsNullable = (atts.SoapElement != null) ? atts.SoapElement.IsNullable : false;
if (typeData.IsComplexType)
{
elem.MappedType = ImportTypeMapping(typeData.Type, defaultNamespace);
}
infoList.Add(elem);
((XmlTypeMapMemberElement)mapMember).ElementInfo = infoList;
}
mapMember.TypeData = typeData;
mapMember.Name = rmember.MemberName;
mapMember.IsReturnValue = rmember.IsReturnValue;
return(mapMember);
}
protected virtual void GenerateDefaultAttribute(CodeMemberField internalField, CodeTypeMember externalField, TypeData typeData, object defaultValue)
{
if (typeData.Type == null)
{
// It must be an enumeration defined in the schema.
if (typeData.SchemaType != SchemaTypes.Enum)
{
throw new InvalidOperationException("Type " + typeData.TypeName + " not supported");
}
IFormattable defaultValueFormattable = defaultValue as IFormattable;
CodeFieldReferenceExpression fref = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(GetDomType(typeData, false)), defaultValueFormattable != null ? defaultValueFormattable.ToString(null, CultureInfo.InvariantCulture) : defaultValue.ToString());
CodeAttributeArgument arg = new CodeAttributeArgument(fref);
AddCustomAttribute(externalField, "System.ComponentModel.DefaultValue", arg);
//internalField.InitExpression = fref;
}
else
{
AddCustomAttribute(externalField, "System.ComponentModel.DefaultValue", GetArg(defaultValue));
//internalField.InitExpression = new CodePrimitiveExpression (defaultValue);
}
}
XmlTypeMapping ImportClassMapping(Type type, string defaultNamespace)
{
TypeData typeData = TypeTranslator.GetTypeData(type);
return(ImportClassMapping(typeData, defaultNamespace));
}
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);
}
protected void WritePotentiallyReferencingElement(string n, string ns, object o, Type ambientType, bool suppressReference, bool isNullable)
{
if (o == null)
{
if (isNullable)
{
WriteNullTagEncoded(n, ns);
}
return;
}
WriteStartElement(n, ns, true);
CheckReferenceQueue();
if (callbacks != null && callbacks.ContainsKey(o.GetType()))
{
WriteCallbackInfo info = (WriteCallbackInfo)callbacks[o.GetType()];
if (o.GetType().IsEnum)
{
info.Callback(o);
}
else if (suppressReference)
{
Writer.WriteAttributeString("id", GetId(o, false));
if (ambientType != o.GetType())
{
WriteXsiType(info.TypeName, info.TypeNs);
}
info.Callback(o);
}
else
{
if (!AlreadyQueued(o))
{
referencedElements.Enqueue(o);
}
Writer.WriteAttributeString("href", "#" + GetId(o, true));
}
}
else
{
// Must be a primitive type or array of primitives
TypeData td = TypeTranslator.GetTypeData(o.GetType());
if (td.SchemaType == SchemaTypes.Primitive)
{
WriteXsiType(td.XmlType, XmlSchema.Namespace);
Writer.WriteString(XmlCustomFormatter.ToXmlString(td, o));
}
else if (IsPrimitiveArray(td))
{
if (!AlreadyQueued(o))
{
referencedElements.Enqueue(o);
}
Writer.WriteAttributeString("href", "#" + GetId(o, true));
}
else
{
throw new InvalidOperationException("Invalid type: " + o.GetType().FullName);
}
}
WriteEndElement();
}
internal TypeData(string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
this.elementName = xmlType;
this.typeName = typeName;
this.fullTypeName = fullTypeName.Replace('+', '.');
this.listItemTypeData = listItemTypeData;
this.sType = schemaType;
this.hasPublicConstructor = true;
}
protected override void GenerateTextElementAttribute(CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
CodeAttributeDeclaration uatt = new CodeAttributeDeclaration("Mpd.Xml.Serialization.XmlTextAttribute");
if (einfo.TypeData.FullTypeName != defaultType.FullTypeName)
{
uatt.Arguments.Add(GetTypeArg("Type", einfo.TypeData.FullTypeName));
}
attributes.Add(uatt);
}
public void AddArrayItemAttributes(CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel)
{
foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo)
{
string defaultName;
if (ainfo.MappedType != null)
{
defaultName = ainfo.MappedType.ElementName;
}
else
{
defaultName = ainfo.TypeData.XmlType;
}
GenerateArrayItemAttributes(attributes, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel);
if (ainfo.MappedType != null)
{
if (!IsMapExported(ainfo.MappedType) && includeArrayTypes)
{
AddInclude(ainfo.MappedType);
}
ExportMapCode(ainfo.MappedType, false);
}
}
if (listMap.IsMultiArray)
{
XmlTypeMapping nmap = listMap.NestedArrayMapping;
AddArrayItemAttributes(attributes, (ListMap)nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1);
}
}
protected override void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration("Mpd.Xml.Serialization.SoapElement");
if (forceUseMemberName || einfo.ElementName != member.Name)
{
att.Arguments.Add(GetArg(einfo.ElementName));
}
// if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true)); MS seems to ignore this
if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData))
{
att.Arguments.Add(GetArg("DataType", einfo.TypeData.XmlType));
}
if (addAlwaysAttr || att.Arguments.Count > 0)
{
attributes.Add(att);
}
}
bool ExportExtraElementAttributes(CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace, TypeData defaultType)
{
if (einfo.IsTextElement)
{
GenerateTextElementAttribute(attributes, einfo, defaultType);
return(true);
}
else if (einfo.IsUnnamedAnyElement)
{
GenerateUnnamedAnyElementAttribute(attributes, einfo, defaultNamespace);
return(true);
}
return(false);
}
public static TypeData GetTypeData(Type runtimeType, string xmlDataType)
{
Type type = runtimeType;
bool nullableOverride = false;
#if NET_2_0
// Nullable<T> is serialized as T
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
nullableOverride = true;
type = type.GetGenericArguments() [0];
TypeData pt = GetTypeData(type); // beware this recursive call btw ...
if (pt != null)
{
TypeData tt = (TypeData)nullableTypes [pt.XmlType];
#if TARGET_JVM
if (tt == null)
{
tt = (TypeData)AppDomain_nullableTypes [pt.XmlType];
}
#endif
if (tt == null)
{
tt = new TypeData(type, pt.XmlType, false);
tt.IsNullable = true;
#if TARGET_JVM
AppDomain_nullableTypes [pt.XmlType] = tt;
#else
nullableTypes [pt.XmlType] = tt;
#endif
}
return(tt);
}
}
#endif
if ((xmlDataType != null) && (xmlDataType.Length != 0))
{
// If the type is an array, xmlDataType specifies the type for the array elements,
// not for the whole array. The exception is base64Binary, since it is a byte[],
// that's why the following check is needed.
TypeData at = GetPrimitiveTypeData(xmlDataType);
if (type.IsArray && type != at.Type)
{
TypeData tt = (TypeData)primitiveArrayTypes [xmlDataType];
if (tt != null)
{
return(tt);
}
if (at.Type == type.GetElementType())
{
tt = new TypeData(type, GetArrayName(at.XmlType), false);
primitiveArrayTypes [xmlDataType] = tt;
return(tt);
}
else
{
throw new InvalidOperationException("Cannot convert values of type '" + type.GetElementType() + "' to '" + xmlDataType + "'");
}
}
return(at);
}
TypeData typeData = nameCache[runtimeType] as TypeData;
if (typeData != null)
{
return(typeData);
}
#if TARGET_JVM
Hashtable dynamicCache = AppDomain_nameCache;
typeData = dynamicCache[runtimeType] as TypeData;
if (typeData != null)
{
return(typeData);
}
#endif
string name;
if (type.IsArray)
{
string sufix = GetTypeData(type.GetElementType()).XmlType;
name = GetArrayName(sufix);
}
#if NET_2_0
else if (type.IsGenericType && !type.IsGenericTypeDefinition)
{
name = XmlConvert.EncodeLocalName(type.Name.Substring(0, type.Name.IndexOf('`'))) + "Of";
foreach (Type garg in type.GetGenericArguments())
{
name += garg.IsArray || garg.IsGenericType ?
GetTypeData(garg).XmlType :
CodeIdentifier.MakePascal(XmlConvert.EncodeLocalName(garg.Name));
}
}
#endif
else
{
name = XmlConvert.EncodeLocalName(type.Name);
}
typeData = new TypeData(type, name, false);
if (nullableOverride)
{
typeData.IsNullable = true;
}
#if TARGET_JVM
dynamicCache[runtimeType] = typeData;
#else
nameCache[runtimeType] = typeData;
#endif
return(typeData);
}
protected virtual void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
}
public static bool IsDefaultPrimitiveTpeData(TypeData primType)
{
return(GetDefaultPrimitiveTypeData(primType) == primType);
}
protected virtual void GenerateTextElementAttribute(CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
}
public static TypeData CreateCustomType(string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
TypeData td = new TypeData(typeName, fullTypeName, xmlType, schemaType, listItemTypeData);
return(td);
}
void ReadMembers(ClassMap map, object ob, bool isValueList, bool readByOrder)
{
// Reads attributes
ReadAttributeMembers(map, ob, isValueList);
if (!isValueList)
{
Reader.MoveToElement();
if (Reader.IsEmptyElement)
{
SetListMembersDefaults(map, ob, isValueList);
return;
}
Reader.ReadStartElement();
}
// Reads elements
bool[] readFlag = new bool[(map.ElementMembers != null) ? map.ElementMembers.Count : 0];
bool hasAnyReturnMember = (isValueList && _format == SerializationFormat.Encoded && map.ReturnMember != null);
Reader.MoveToContent();
int[] indexes = null;
object[] flatLists = null;
object[] flatListsChoices = null;
Fixup fixup = null;
int ind = 0;
int maxInd;
if (readByOrder)
{
if (map.ElementMembers != null)
{
maxInd = map.ElementMembers.Count;
}
else
{
maxInd = 0;
}
}
else
{
maxInd = int.MaxValue;
}
if (map.FlatLists != null)
{
indexes = new int[map.FlatLists.Count];
flatLists = new object[map.FlatLists.Count];
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
{
if (IsReadOnly(mem, mem.TypeData, ob, isValueList))
{
flatLists [mem.FlatArrayIndex] = mem.GetValue(ob);
}
else if (mem.TypeData.Type.IsArray)
{
flatLists [mem.FlatArrayIndex] = InitializeList(mem.TypeData);
}
else
{
object list = mem.GetValue(ob);
if (list == null)
{
list = InitializeList(mem.TypeData);
SetMemberValue(mem, ob, list, isValueList);
}
flatLists [mem.FlatArrayIndex] = list;
}
if (mem.ChoiceMember != null)
{
if (flatListsChoices == null)
{
flatListsChoices = new object [map.FlatLists.Count];
}
flatListsChoices [mem.FlatArrayIndex] = InitializeList(mem.ChoiceTypeData);
}
}
}
if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
{
FixupCallbackInfo info = new FixupCallbackInfo(this, map, isValueList);
fixup = new Fixup(ob, new XmlSerializationFixupCallback(info.FixupMembers), map.ElementMembers.Count);
AddFixup(fixup);
}
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd))
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
XmlTypeMapElementInfo info;
if (readByOrder)
{
info = map.GetElement(ind++);
}
else if (hasAnyReturnMember)
{
info = (XmlTypeMapElementInfo)((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0];
hasAnyReturnMember = false;
}
else
{
info = map.GetElement(Reader.LocalName, Reader.NamespaceURI);
}
if (info != null && !readFlag[info.Member.Index])
{
if (info.Member.GetType() == typeof(XmlTypeMapMemberList))
{
if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
{
object list = ReadReferencingElement(out fixup.Ids[info.Member.Index]);
if (fixup.Ids[info.Member.Index] == null) // Already read
{
if (IsReadOnly(info.Member, info.TypeData, ob, isValueList))
{
throw CreateReadOnlyCollectionException(info.TypeData.FullTypeName);
}
else
{
SetMemberValue(info.Member, ob, list, isValueList);
}
}
else if (!info.MappedType.TypeData.Type.IsArray)
{
if (IsReadOnly(info.Member, info.TypeData, ob, isValueList))
{
list = GetMemberValue(info.Member, ob, isValueList);
}
else
{
list = CreateList(info.MappedType.TypeData.Type);
SetMemberValue(info.Member, ob, list, isValueList);
}
AddFixup(new CollectionFixup(list, new XmlSerializationCollectionFixupCallback(FillList), fixup.Ids[info.Member.Index]));
fixup.Ids[info.Member.Index] = null; // The member already has the value, no further fix needed.
}
}
else
{
if (IsReadOnly(info.Member, info.TypeData, ob, isValueList))
{
ReadListElement(info.MappedType, info.IsNullable, GetMemberValue(info.Member, ob, isValueList), false);
}
else if (info.MappedType.TypeData.Type.IsArray)
{
object list = ReadListElement(info.MappedType, info.IsNullable, null, true);
if (list != null || info.IsNullable)
{
SetMemberValue(info.Member, ob, list, isValueList);
}
}
else
{
// If the member already has a list, reuse that list. No need to create a new one.
object list = GetMemberValue(info.Member, ob, isValueList);
if (list == null)
{
list = CreateList(info.MappedType.TypeData.Type);
SetMemberValue(info.Member, ob, list, isValueList);
}
ReadListElement(info.MappedType, info.IsNullable, list, true);
}
}
readFlag[info.Member.Index] = true;
}
else if (info.Member.GetType() == typeof(XmlTypeMapMemberFlatList))
{
XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement(info), !IsReadOnly(info.Member, info.TypeData, ob, isValueList));
if (mem.ChoiceMember != null)
{
AddListValue(mem.ChoiceTypeData, ref flatListsChoices [mem.FlatArrayIndex], indexes[mem.FlatArrayIndex] - 1, info.ChoiceValue, true);
}
}
else if (info.Member.GetType() == typeof(XmlTypeMapMemberAnyElement))
{
XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
if (mem.TypeData.IsListType)
{
AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
}
else
{
SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList);
}
}
else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
{
object val;
readFlag[info.Member.Index] = true;
if (_format == SerializationFormat.Encoded)
{
if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
{
val = ReadReferencingElement(out fixup.Ids[info.Member.Index]);
}
else
{
val = ReadReferencingElement(info.Member.TypeData.XmlType, System.Xml.Schema.XmlSchema.Namespace, out fixup.Ids[info.Member.Index]);
}
if (info.MultiReferenceType)
{
if (fixup.Ids[info.Member.Index] == null) // already read
{
SetMemberValue(info.Member, ob, val, isValueList);
}
}
else if (val != null)
{
SetMemberValue(info.Member, ob, val, isValueList);
}
}
else
{
SetMemberValue(info.Member, ob, ReadObjectElement(info), isValueList);
if (info.ChoiceValue != null)
{
XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement)info.Member;
imem.SetChoice(ob, info.ChoiceValue);
}
}
}
else
{
throw new InvalidOperationException("Unknown member type");
}
}
else if (map.DefaultAnyElementMember != null)
{
XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
if (mem.TypeData.IsListType)
{
AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
}
else
{
SetMemberValue(mem, ob, ReadXmlNode(mem.TypeData, false), isValueList);
}
}
else
{
ProcessUnknownElement(ob);
}
}
else if ((Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA) && map.XmlTextCollector != null)
{
if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
{
XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
object val = (itype.Type == typeof(string)) ? (object)Reader.ReadString() : (object)ReadXmlNode(itype, false);
AddListValue(mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, val, true);
}
else
{
XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.XmlTextCollector;
XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)mem.ElementInfo [0];
if (info.TypeData.Type == typeof(string))
{
SetMemberValue(mem, ob, ReadString((string)GetMemberValue(mem, ob, isValueList)), isValueList);
}
else
{
SetMemberValue(mem, ob, GetValueFromXmlString(Reader.ReadString(), info.TypeData, info.MappedType), isValueList);
}
}
}
else
{
UnknownNode(ob);
}
Reader.MoveToContent();
}
if (flatLists != null)
{
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
{
Object list = flatLists[mem.FlatArrayIndex];
if (mem.TypeData.Type.IsArray)
{
list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true);
}
if (!IsReadOnly(mem, mem.TypeData, ob, isValueList) && mem.TypeData.Type.IsArray)
{
SetMemberValue(mem, ob, list, isValueList);
}
}
}
if (flatListsChoices != null)
{
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
{
Object list = flatListsChoices[mem.FlatArrayIndex];
if (list == null)
{
continue;
}
list = ShrinkArray((Array)list, indexes[mem.FlatArrayIndex], mem.ChoiceTypeData.Type.GetElementType(), true);
XmlTypeMapMember.SetValue(ob, mem.ChoiceMember, list);
}
}
SetListMembersDefaults(map, ob, isValueList);
}
protected override void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration("Mpd.Xml.Serialization.XmlElementAttribute");
if (forceUseMemberName || einfo.ElementName != member.Name)
{
att.Arguments.Add(GetArg(einfo.ElementName));
}
if (einfo.TypeData.FullTypeName != defaultType.FullTypeName)
{
att.Arguments.Add(GetTypeArg("Type", einfo.TypeData.FullTypeName));
}
if (einfo.Namespace != defaultNamespace)
{
att.Arguments.Add(GetArg("Namespace", einfo.Namespace));
}
if (einfo.Form == XmlSchemaForm.Unqualified)
{
att.Arguments.Add(GetEnumArg("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString()));
}
if (einfo.IsNullable)
{
att.Arguments.Add(GetArg("IsNullable", true));
}
if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData))
{
att.Arguments.Add(GetArg("DataType", einfo.TypeData.XmlType));
}
if (addAlwaysAttr || att.Arguments.Count > 0)
{
attributes.Add(att);
}
}
