XmlTypeMapElementInfo CreateTextElementInfo (string ns, XmlTypeMapMember member, TypeData typeData)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.IsTextElement = true;
einfo.WrappedElement = false;
if (typeData.IsComplexType)
einfo.MappedType = GetTypeMapping (typeData);
return einfo;
}
string GenerateReadPrimitiveValue (XmlTypeMapElementInfo elem)
{
if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
if (elem.IsNullable) return "ReadNullableQualifiedName ()";
else return "ReadElementQualifiedName ()";
}
else if (elem.IsNullable) {
string str = GetStrTempVar ();
WriteLine ("string " + str + " = ReadNullableString ();");
return GenerateGetValueFromXmlString (str, elem.TypeData, elem.MappedType, true);
}
else {
string str = GetStrTempVar ();
WriteLine ("string " + str + " = Reader.ReadElementString ();");
return GenerateGetValueFromXmlString (str, elem.TypeData, elem.MappedType, false);
}
}
bool ImportChoices (XmlQualifiedName typeQName, XmlTypeMapMember member, XmlTypeMapElementInfoList choices, XmlSchemaObjectCollection items)
{
bool multiValue = false;
foreach (XmlSchemaObject titem in items)
{
XmlSchemaObject item = titem;
if (item is XmlSchemaGroupRef)
item = GetRefGroupParticle ((XmlSchemaGroupRef)item);
if (item is XmlSchemaElement)
{
string ns;
XmlSchemaElement elem = (XmlSchemaElement) item;
XmlTypeMapping emap;
TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
choices.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, -1));
if (elem.MaxOccurs > 1) multiValue = true;
}
else if (item is XmlSchemaAny)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement)));
einfo.IsUnnamedAnyElement = true;
choices.Add (einfo);
}
else if (item is XmlSchemaChoice) {
multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaChoice)item).Items) || multiValue;
}
else if (item is XmlSchemaSequence) {
multiValue = ImportChoices (typeQName, member, choices, ((XmlSchemaSequence)item).Items) || multiValue;
}
}
return multiValue;
}
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;
}
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.ElementName = name;
einfo.Namespace = ns;
einfo.IsNullable = isNillable;
einfo.Form = form;
if (typeData.IsComplexType)
einfo.MappedType = emap;
return einfo;
}
XmlTypeMapElementInfoList ImportElementInfo (Type cls, string defaultName, string defaultNamespace, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts)
{
EnumMap choiceEnumMap = null;
Type choiceEnumType = null;
XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList();
ImportTextElementInfo (list, defaultType, member, atts, defaultNamespace);
if (atts.XmlChoiceIdentifier != null) {
if (cls == null)
throw new InvalidOperationException ("XmlChoiceIdentifierAttribute not supported in this context.");
member.ChoiceMember = atts.XmlChoiceIdentifier.MemberName;
MemberInfo[] mems = cls.GetMember (member.ChoiceMember, BindingFlags.Instance|BindingFlags.Public);
if (mems.Length == 0)
throw new InvalidOperationException ("Choice member '" + member.ChoiceMember + "' not found in class '" + cls);
if (mems[0] is PropertyInfo) {
PropertyInfo pi = (PropertyInfo)mems[0];
if (!pi.CanWrite || !pi.CanRead)
throw new InvalidOperationException ("Choice property '" + member.ChoiceMember + "' must be read/write.");
choiceEnumType = pi.PropertyType;
}
else choiceEnumType = ((FieldInfo)mems[0]).FieldType;
member.ChoiceTypeData = TypeTranslator.GetTypeData (choiceEnumType);
if (choiceEnumType.IsArray)
choiceEnumType = choiceEnumType.GetElementType ();
choiceEnumMap = ImportTypeMapping (choiceEnumType).ObjectMap as EnumMap;
if (choiceEnumMap == null)
throw new InvalidOperationException ("The member '" + mems[0].Name + "' is not a valid target for XmlChoiceIdentifierAttribute.");
}
if (atts.XmlElements.Count == 0 && list.Count == 0)
{
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType));
elem.ElementName = defaultName;
elem.Namespace = defaultNamespace;
if (elem.TypeData.IsComplexType)
elem.MappedType = ImportTypeMapping (defaultType, null, defaultNamespace);
list.Add (elem);
}
bool multiType = (atts.XmlElements.Count > 1);
foreach (XmlElementAttribute att in atts.XmlElements)
{
Type elemType = (att.Type != null) ? att.Type : defaultType;
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(elemType, att.DataType));
elem.Form = att.Form;
if (elem.Form != XmlSchemaForm.Unqualified)
elem.Namespace = (att.Namespace != null) ? att.Namespace : defaultNamespace;
elem.IsNullable = att.IsNullable;
if (elem.IsNullable && !elem.TypeData.IsNullable)
throw new InvalidOperationException ("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName + " in member '" + defaultName + "'");
if (elem.TypeData.IsComplexType)
{
if (att.DataType.Length != 0) throw new InvalidOperationException (
string.Format(CultureInfo.InvariantCulture, "'{0}' is "
+ "an invalid value for '{1}.{2}' of type '{3}'. "
+ "The property may only be specified for primitive types.",
att.DataType, cls.FullName, defaultName,
elem.TypeData.FullTypeName));
elem.MappedType = ImportTypeMapping (elemType, null, elem.Namespace);
}
if (att.ElementName.Length != 0) {
elem.ElementName = XmlConvert.EncodeLocalName(att.ElementName);
} else if (multiType) {
if (elem.MappedType != null) {
elem.ElementName = elem.MappedType.ElementName;
} else {
elem.ElementName = TypeTranslator.GetTypeData (elemType).XmlType;
}
} else {
elem.ElementName = defaultName;
}
if (choiceEnumMap != null) {
string cname = choiceEnumMap.GetEnumName (choiceEnumType.FullName, elem.ElementName);
if (cname == null)
throw new InvalidOperationException (string.Format (
CultureInfo.InvariantCulture, "Type {0} is missing"
+ " enumeration value '{1}' for element '{1} from"
+ " namespace '{2}'.", choiceEnumType, elem.ElementName,
elem.Namespace));
elem.ChoiceValue = Enum.Parse (choiceEnumType, cname, false);
}
list.Add (elem);
}
return list;
}
protected override void GenerateUnnamedAnyElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace)
{
CodeAttributeDeclaration uatt = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlAnyElement");
if (!einfo.IsUnnamedAnyElement) uatt.Arguments.Add (GetArg ("Name", einfo.ElementName));
if (einfo.Namespace != defaultNamespace) uatt.Arguments.Add (GetArg ("Namespace", einfo.Namespace));
attributes.Add (uatt);
}
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 virtual void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
{
}
void ReadMembers(ClassMap map, object ob, bool isValueList, bool readByOrder)
{
// Set the default values of the members
if (map.MembersWithDefault != null)
{
ArrayList members = map.MembersWithDefault;
for (int n = 0; n < members.Count; n++)
{
XmlTypeMapMember mem = (XmlTypeMapMember)members[n];
SetMemberValueFromAttr(mem, ob, mem.DefaultValue, isValueList);
}
}
// Reads attributes
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
int anyAttributeIndex = 0;
object anyAttributeArray = null;
while (Reader.MoveToNextAttribute())
{
XmlTypeMapMemberAttribute member = map.GetAttribute(Reader.LocalName, Reader.NamespaceURI);
if (member != null)
{
SetMemberValue(member, ob, GetValueFromXmlString(Reader.Value, member.TypeData, member.MappedType), isValueList);
}
else if (IsXmlnsAttribute(Reader.Name))
{
// If the map has NamespaceDeclarations,
// then store this xmlns to the given member.
// If the instance doesn't exist, then create.
if (map.NamespaceDeclarations != null)
{
XmlSerializerNamespaces nss = this.GetMemberValue(map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces;
if (nss == null)
{
nss = new XmlSerializerNamespaces();
SetMemberValue(map.NamespaceDeclarations, ob, nss, isValueList);
}
if (Reader.Prefix == "xmlns")
{
nss.Add(Reader.LocalName, Reader.Value);
}
else
{
nss.Add("", Reader.Value);
}
}
}
else if (anyAttrMember != null)
{
XmlAttribute attr = (XmlAttribute)Document.ReadNode(Reader);
ParseWsdlArrayType(attr);
AddListValue(anyAttrMember.TypeData, ref anyAttributeArray, anyAttributeIndex++, attr, true);
}
else
{
ProcessUnknownAttribute(ob);
}
}
if (anyAttrMember != null)
{
anyAttributeArray = ShrinkArray((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
SetMemberValue(anyAttrMember, ob, anyAttributeArray, isValueList);
}
if (!isValueList)
{
Reader.MoveToElement();
if (Reader.IsEmptyElement)
{
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 &&
map.ReturnMember.TypeData.Type == typeof(object));
Reader.MoveToContent();
int[] indexes = null;
object[] flatLists = 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, ob, isValueList))
{
flatLists[mem.FlatArrayIndex] = mem.GetValue(ob);
}
}
}
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, 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, 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, ob, isValueList))
{
ReadListElement(info.MappedType, info.IsNullable, GetMemberValue(info.Member, ob, isValueList), false);
}
else
{
SetMemberValue(info.Member, ob, ReadListElement(info.MappedType, info.IsNullable, null, true), isValueList);
}
}
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, ob, isValueList));
}
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)
{
val = ReadReferencingElement(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);
}
}
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 && 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.Read();
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, ob, isValueList))
{
SetMemberValue(mem, ob, list, isValueList);
}
}
}
}
object ReadListElement(XmlTypeMapping typeMap, bool isNullable, object list, bool canCreateInstance)
{
Type listType = typeMap.TypeData.Type;
ListMap listMap = (ListMap)typeMap.ObjectMap;
if (ReadNull())
{
return(null);
}
if (list == null)
{
if (canCreateInstance)
{
list = CreateList(listType);
}
else
{
throw CreateReadOnlyCollectionException(typeMap.TypeFullName);
}
}
if (Reader.IsEmptyElement)
{
Reader.Skip();
if (listType.IsArray)
{
list = ShrinkArray((Array)list, 0, listType.GetElementType(), isNullable);
}
return(list);
}
int index = 0;
Reader.ReadStartElement();
Reader.MoveToContent();
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
XmlTypeMapElementInfo elemInfo = listMap.FindElement(Reader.LocalName, Reader.NamespaceURI);
if (elemInfo != null)
{
AddListValue(typeMap.TypeData, ref list, index++, ReadObjectElement(elemInfo), false);
}
else
{
UnknownNode(null);
}
}
else
{
UnknownNode(null);
}
Reader.MoveToContent();
}
ReadEndElement();
if (listType.IsArray)
{
list = ShrinkArray((Array)list, index, listType.GetElementType(), isNullable);
}
return(list);
}
protected override void GenerateUnnamedAnyElementAttribute(CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace)
{
CodeAttributeDeclaration uatt = new CodeAttributeDeclaration("System.Xml.Serialization.XmlAnyElement");
if (!einfo.IsUnnamedAnyElement)
{
uatt.Arguments.Add(GetArg("Name", einfo.ElementName));
}
if (einfo.Namespace != defaultNamespace)
{
uatt.Arguments.Add(GetArg("Namespace", einfo.Namespace));
}
attributes.Add(uatt);
}
protected override void GenerateTextElementAttribute(CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
CodeAttributeDeclaration uatt = new CodeAttributeDeclaration("System.Xml.Serialization.XmlTextAttribute");
if (einfo.TypeData.FullTypeName != defaultType.FullTypeName)
{
uatt.Arguments.Add(GetTypeArg("Type", einfo.TypeData.FullTypeName));
}
attributes.Add(uatt);
}
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("System.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);
}
}
XmlTypeMapElementInfoList ImportAnyElementInfo (string defaultNamespace, XmlReflectionMember rmember, XmlTypeMapMemberElement member, XmlAttributes atts)
{
XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList();
ImportTextElementInfo (list, rmember.MemberType, member, atts, defaultNamespace);
#if !MOONLIGHT // no practical anyElement support
foreach (XmlAnyElementAttribute att in atts.XmlAnyElements)
{
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(typeof(XmlElement)));
if (att.Name.Length != 0)
{
elem.ElementName = XmlConvert.EncodeLocalName(att.Name);
elem.Namespace = (att.Namespace != null) ? att.Namespace : "";
}
else
{
elem.IsUnnamedAnyElement = true;
elem.Namespace = defaultNamespace;
if (att.Namespace != null)
throw new InvalidOperationException ("The element " + rmember.MemberName + " has been attributed with an XmlAnyElementAttribute and a namespace '" + att.Namespace + "', but no name. When a namespace is supplied, a name is also required. Supply a name or remove the namespace.");
}
list.Add (elem);
}
#endif
return list;
}
protected virtual void GenerateTextElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
}
XmlTypeMapping ImportListMapping (TypeData typeData, XmlRootAttribute root, string defaultNamespace, XmlAttributes atts, int nestingLevel)
{
Type type = typeData.Type;
ListMap obmap = new ListMap ();
if (!allowPrivateTypes)
ReflectionHelper.CheckSerializableType (type, true);
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.Namespace != null && att.Form == XmlSchemaForm.Unqualified)
throw new InvalidOperationException ("XmlArrayItemAttribute.Form must not be Unqualified when it has an explicit Namespace value.");
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;
if (att.Form == XmlSchemaForm.Unqualified)
elem.Namespace = string.Empty;
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.Length != 0) {
elem.ElementName = XmlConvert.EncodeLocalName (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;
}
protected virtual void GenerateUnnamedAnyElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, string defaultNamespace)
{
}
protected override void GenerateElementInfoMember(CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.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);
}
}
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 (atts.SoapElement != null)
throw new Exception ("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member");
XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute ();
if (atts.SoapAttribute.AttributeName == null)
mapAttribute.AttributeName = rmember.MemberName;
else
mapAttribute.AttributeName = 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;
}
else
{
if (typeData.SchemaType == SchemaTypes.Array) mapMember = new XmlTypeMapMemberList ();
else mapMember = new XmlTypeMapMemberElement ();
if (atts.SoapElement != null && atts.SoapElement.DataType != null)
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 = (atts.SoapElement != null && atts.SoapElement.ElementName != null) ? 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;
}
XmlTypeMapping ImportListMapping (TypeData typeData, string defaultNamespace)
{
Type type = typeData.Type;
XmlTypeMapping map = helper.GetRegisteredClrType (type, XmlSerializer.EncodingNamespace);
if (map != null) return map;
ListMap obmap = new ListMap ();
TypeData itemTypeData = typeData.ListItemTypeData;
map = CreateTypeMapping (typeData, "Array", XmlSerializer.EncodingNamespace);
helper.RegisterClrType (map, type, XmlSerializer.EncodingNamespace);
map.MultiReferenceType = true;
map.ObjectMap = obmap;
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (null, itemTypeData);
if (elem.TypeData.IsComplexType) {
elem.MappedType = ImportTypeMapping (typeData.ListItemType, defaultNamespace);
elem.TypeData = elem.MappedType.TypeData;
}
elem.ElementName = "Item";
elem.Namespace = string.Empty;
elem.IsNullable = true; // By default, items are nullable
XmlTypeMapElementInfoList list = new XmlTypeMapElementInfoList();
list.Add (elem);
obmap.ItemInfo = list;
XmlTypeMapping objMap = ImportTypeMapping (typeof(object), defaultNamespace);
objMap.DerivedTypes.Add (map);
// Register any of the including types as a derived class of object
SoapIncludeAttribute[] includes = (SoapIncludeAttribute[])type.GetCustomAttributes (typeof (SoapIncludeAttribute), false);
for (int i = 0; i < includes.Length; i++)
{
Type includedType = includes[i].Type;
objMap.DerivedTypes.Add(ImportTypeMapping (includedType, defaultNamespace));
}
return map;
}
object ReadObjectElement (XmlTypeMapElementInfo elem)
{
switch (elem.TypeData.SchemaType)
{
case SchemaTypes.XmlNode:
return ReadXmlNode (elem.TypeData, true);
case SchemaTypes.Primitive:
case SchemaTypes.Enum:
return ReadPrimitiveValue (elem);
case SchemaTypes.Array:
return ReadListElement (elem.MappedType, elem.IsNullable, null, true);
case SchemaTypes.Class:
return ReadObject (elem.MappedType, elem.IsNullable, true);
case SchemaTypes.XmlSerializable:
object ob = Activator.CreateInstance (elem.TypeData.Type, true);
return ReadSerializable ((IXmlSerializable)ob);
default:
throw new NotSupportedException ("Invalid value type");
}
}
void WriteMemberElement (XmlTypeMapElementInfo elem, object memberValue)
{
switch (elem.TypeData.SchemaType)
{
case SchemaTypes.XmlNode:
string elemName = elem.WrappedElement ? elem.ElementName : "";
if (_format == SerializationFormat.Literal) WriteElementLiteral(((XmlNode)memberValue), elemName, elem.Namespace, elem.IsNullable, false);
else WriteElementEncoded(((XmlNode)memberValue), elemName, elem.Namespace, elem.IsNullable, false);
break;
case SchemaTypes.Enum:
case SchemaTypes.Primitive:
if (_format == SerializationFormat.Literal)
WritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
else
WritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.DataTypeName, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
break;
case SchemaTypes.Array:
if (memberValue == null) {
if (!elem.IsNullable) return;
if (_format == SerializationFormat.Literal) WriteNullTagLiteral (elem.ElementName, elem.Namespace);
else WriteNullTagEncoded (elem.ElementName, elem.Namespace);
}
else if (elem.MappedType.MultiReferenceType)
WriteReferencingElement (elem.ElementName, elem.Namespace, memberValue, elem.IsNullable);
else {
WriteStartElement(elem.ElementName, elem.Namespace, memberValue);
WriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, null);
WriteEndElement (memberValue);
}
break;
case SchemaTypes.Class:
if (elem.MappedType.MultiReferenceType) {
if (elem.MappedType.TypeData.Type == typeof(object))
WritePotentiallyReferencingElement (elem.ElementName, elem.Namespace, memberValue, null, false, elem.IsNullable);
else
WriteReferencingElement (elem.ElementName, elem.Namespace, memberValue, elem.IsNullable);
}
else WriteObject (elem.MappedType, memberValue, elem.ElementName, elem.Namespace, elem.IsNullable, false, true);
break;
case SchemaTypes.XmlSerializable:
// bug #419973
if (!elem.MappedType.TypeData.Type.IsInstanceOfType (memberValue))
memberValue = ImplicitConvert (memberValue, elem.MappedType.TypeData.Type);
WriteSerializable ((IXmlSerializable) memberValue, elem.ElementName, elem.Namespace, elem.IsNullable);
break;
default:
throw new NotSupportedException ("Invalid value type");
}
}
object ReadPrimitiveValue (XmlTypeMapElementInfo elem)
{
if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
if (elem.IsNullable) return ReadNullableQualifiedName ();
else return ReadElementQualifiedName ();
}
else if (elem.IsNullable)
return GetValueFromXmlString (ReadNullableString (), elem.TypeData, elem.MappedType);
else
return GetValueFromXmlString (Reader.ReadElementString (), elem.TypeData, elem.MappedType);
}
string GenerateReadObjectElement (XmlTypeMapElementInfo elem)
{
switch (elem.TypeData.SchemaType)
{
case SchemaTypes.XmlNode:
return GetReadXmlNode (elem.TypeData, true);
case SchemaTypes.Primitive:
case SchemaTypes.Enum:
return GenerateReadPrimitiveValue (elem);
case SchemaTypes.Array:
return GenerateReadListElement (elem.MappedType, null, GetLiteral(elem.IsNullable), true);
case SchemaTypes.Class:
return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
case SchemaTypes.XmlSerializable:
return GetCast (elem.TypeData, String.Format ("({0}) ReadSerializable (({0}) Activator.CreateInstance(typeof({0}), true))", elem.TypeData.CSharpFullName));
default:
throw new NotSupportedException ("Invalid value type");
}
}
public void ExportTypeMapping (XmlTypeMapping xmlTypeMapping)
{
if (!xmlTypeMapping.IncludeInSchema) return;
if (IsElementExported (xmlTypeMapping)) return;
if (encodedFormat)
{
ExportClassSchema (xmlTypeMapping);
XmlSchema schema = GetSchema (xmlTypeMapping.XmlTypeNamespace);
ImportNamespace (schema, XmlSerializer.EncodingNamespace);
}
else
{
XmlSchema schema = GetSchema (xmlTypeMapping.Namespace);
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (null, xmlTypeMapping.TypeData);
einfo.Namespace = xmlTypeMapping.Namespace;
einfo.ElementName = xmlTypeMapping.ElementName;
if (xmlTypeMapping.TypeData.IsComplexType)
einfo.MappedType = xmlTypeMapping;
einfo.IsNullable = xmlTypeMapping.IsNullable;
GetSchemaElement (schema, einfo, false, new XmlSchemaObjectContainer (schema));
SetElementExported (xmlTypeMapping);
}
CompileSchemas ();
}
void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
{
switch (elem.TypeData.SchemaType)
{
case SchemaTypes.XmlNode:
string elemName = elem.WrappedElement ? elem.ElementName : "";
if (_format == SerializationFormat.Literal)
WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
else
WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
break;
case SchemaTypes.Enum:
case SchemaTypes.Primitive:
if (_format == SerializationFormat.Literal)
GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
else
GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
break;
case SchemaTypes.Array:
WriteLineInd ("if (" + memberValue + " != null) {");
if (elem.MappedType.MultiReferenceType) {
WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
RegisterReferencingMap (elem.MappedType);
}
else {
WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
GenerateWriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
WriteMetCall ("WriteEndElement", memberValue);
}
WriteLineUni ("}");
if (elem.IsNullable) {
WriteLineInd ("else");
if (_format == SerializationFormat.Literal)
WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
else
WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
Unindent ();
}
break;
case SchemaTypes.Class:
if (elem.MappedType.MultiReferenceType) {
RegisterReferencingMap (elem.MappedType);
if (elem.MappedType.TypeData.Type == typeof(object))
WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
else
WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
}
else
WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
break;
case SchemaTypes.XmlSerializable:
WriteMetCall ("WriteSerializable", "(" + ToCSharpFullName (elem.MappedType.TypeData.Type) + ") " + memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
break;
default:
throw new NotSupportedException ("Invalid value type");
}
}
XmlSchemaParticle GetSchemaElement (XmlSchema currentSchema, XmlTypeMapElementInfo einfo, bool isTypeMember, XmlSchemaObjectContainer container)
{
return GetSchemaElement (currentSchema, einfo, System.DBNull.Value, isTypeMember, container);
}
XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap, int order)
{
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);
einfo.ElementName = name;
einfo.Namespace = ns;
einfo.IsNullable = isNillable;
einfo.Form = GetForm (form, ns, true);
if (typeData.IsComplexType)
einfo.MappedType = emap;
einfo.ExplicitOrder = order;
return einfo;
}
XmlSchemaParticle GetSchemaElement (XmlSchema currentSchema, XmlTypeMapElementInfo einfo, object defaultValue, bool isTypeMember, XmlSchemaObjectContainer container)
{
if (einfo.IsTextElement) return null;
if (einfo.IsUnnamedAnyElement)
{
XmlSchemaAny any = new XmlSchemaAny ();
any.MinOccurs = 0;
any.MaxOccurs = 1;
if (container != null)
container.Items.Add (any);
return any;
}
XmlSchemaElement selem = new XmlSchemaElement ();
selem.IsNillable = einfo.IsNullable;
if (container != null)
container.Items.Add (selem);
if (isTypeMember)
{
selem.MaxOccurs = 1;
selem.MinOccurs = einfo.IsNullable ? 1 : 0;
if ((defaultValue == DBNull.Value && einfo.TypeData.IsValueType && einfo.Member != null && !einfo.Member.IsOptionalValueType) || encodedFormat)
selem.MinOccurs = 1;
}
XmlSchema memberSchema = null;
if (!encodedFormat)
{
memberSchema = GetSchema (einfo.Namespace);
ImportNamespace (currentSchema, einfo.Namespace);
}
if (currentSchema == memberSchema || encodedFormat || !isTypeMember)
{
if (isTypeMember) selem.IsNillable = einfo.IsNullable;
selem.Name = einfo.ElementName;
if (defaultValue != System.DBNull.Value)
selem.DefaultValue = ExportDefaultValue (einfo.TypeData,
einfo.MappedType, defaultValue);
if (einfo.Form != XmlSchemaForm.Qualified)
selem.Form = einfo.Form;
switch (einfo.TypeData.SchemaType)
{
case SchemaTypes.XmlNode:
selem.SchemaType = GetSchemaXmlNodeType ();
break;
case SchemaTypes.XmlSerializable:
SetSchemaXmlSerializableType (einfo.MappedType as XmlSerializableMapping, selem);
ExportXmlSerializableSchema (currentSchema, einfo.MappedType as XmlSerializableMapping);
break;
case SchemaTypes.Enum:
selem.SchemaTypeName = new XmlQualifiedName (einfo.MappedType.XmlType, einfo.MappedType.XmlTypeNamespace);
ImportNamespace (currentSchema, einfo.MappedType.XmlTypeNamespace);
ExportEnumSchema (einfo.MappedType);
break;
case SchemaTypes.Array:
XmlQualifiedName atypeName = ExportArraySchema (einfo.MappedType, currentSchema.TargetNamespace);
selem.SchemaTypeName = atypeName;
ImportNamespace (currentSchema, atypeName.Namespace);
break;
case SchemaTypes.Class:
if (einfo.MappedType.TypeData.Type != typeof(object)) {
selem.SchemaTypeName = new XmlQualifiedName (einfo.MappedType.XmlType, einfo.MappedType.XmlTypeNamespace);
ImportNamespace (currentSchema, einfo.MappedType.XmlTypeNamespace);
}
else if (encodedFormat)
selem.SchemaTypeName = new XmlQualifiedName (einfo.MappedType.XmlType, einfo.MappedType.XmlTypeNamespace);
ExportClassSchema (einfo.MappedType);
break;
case SchemaTypes.Primitive:
selem.SchemaTypeName = new XmlQualifiedName (einfo.TypeData.XmlType, einfo.DataTypeNamespace);
if (!einfo.TypeData.IsXsdType) {
ImportNamespace (currentSchema, einfo.MappedType.XmlTypeNamespace);
ExportDerivedSchema (einfo.MappedType);
}
break;
}
}
else
{
selem.RefName = new XmlQualifiedName (einfo.ElementName, einfo.Namespace);
foreach (XmlSchemaObject ob in memberSchema.Items)
if (ob is XmlSchemaElement && ((XmlSchemaElement)ob).Name == einfo.ElementName)
return selem;
GetSchemaElement (memberSchema, einfo, defaultValue, false,
new XmlSchemaObjectContainer (memberSchema));
}
return selem;
}
void ImportSequenceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection items, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
{
foreach (XmlSchemaObject item in items)
{
if (item is XmlSchemaElement)
{
string ns;
XmlSchemaElement elem = (XmlSchemaElement) item;
XmlTypeMapping emap;
TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
if (elem.MaxOccurs == 1 && !multiValue)
{
XmlTypeMapMemberElement member = null;
if (typeData.SchemaType != SchemaTypes.Array)
{
member = new XmlTypeMapMemberElement ();
if (refElem.DefaultValue != null) member.DefaultValue = ImportDefaultValue (typeData, refElem.DefaultValue);
}
else if (GetTypeMapping (typeData).IsSimpleType)
{
// It is a simple list (space separated list).
// Since this is not supported, map as a single item value
member = new XmlTypeMapMemberElement ();
#if NET_2_0
// In MS.NET those types are mapped to a string
typeData = TypeTranslator.GetTypeData(typeof(string));
#else
typeData = typeData.ListItemTypeData;
#endif
}
else
member = new XmlTypeMapMemberList ();
if (elem.MinOccurs == 0 && typeData.IsValueType)
member.IsOptionalValueType = true;
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
cmap.AddMember (member);
}
else
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.ListMap = new ListMap ();
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData.ListTypeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
else if (item is XmlSchemaAny)
{
XmlSchemaAny elem = (XmlSchemaAny) item;
XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement ();
member.Name = classIds.AddUnique ("Any", member);
member.Documentation = GetDocumentation (elem);
Type ctype;
if (elem.MaxOccurs != 1 || multiValue)
ctype = isMixed ? typeof(XmlNode[]) : typeof(XmlElement[]);
else
ctype = isMixed ? typeof(XmlNode) : typeof(XmlElement);
member.TypeData = TypeTranslator.GetTypeData (ctype);
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, member.TypeData);
einfo.IsUnnamedAnyElement = true;
member.ElementInfo.Add (einfo);
if (isMixed)
{
einfo = CreateTextElementInfo (typeQName.Namespace, member, member.TypeData);
member.ElementInfo.Add (einfo);
member.IsXmlTextCollector = true;
isMixed = false; //Allow only one XmlTextAttribute
}
cmap.AddMember (member);
}
else if (item is XmlSchemaParticle) {
ImportParticleContent (typeQName, cmap, (XmlSchemaParticle)item, classIds, multiValue, ref isMixed);
}
}
}
protected override void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.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);
}
void ImportTextElementInfo (XmlTypeMapElementInfoList list, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts, string defaultNamespace)
{
if (atts.XmlText != null)
{
member.IsXmlTextCollector = true;
if (atts.XmlText.Type != null) {
TypeData td = TypeTranslator.GetTypeData (defaultType);
if ((td.SchemaType == SchemaTypes.Primitive || td.SchemaType == SchemaTypes.Enum) && atts.XmlText.Type != defaultType) {
throw new InvalidOperationException ("The type for XmlText may not be specified for primitive types.");
}
defaultType = atts.XmlText.Type;
}
#if !MOONLIGHT
if (defaultType == typeof(XmlNode)) defaultType = typeof(XmlText); // Nodes must be text nodes
#endif
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, TypeTranslator.GetTypeData(defaultType, atts.XmlText.DataType));
if (elem.TypeData.SchemaType != SchemaTypes.Primitive &&
elem.TypeData.SchemaType != SchemaTypes.Enum &&
elem.TypeData.SchemaType != SchemaTypes.XmlNode &&
!(elem.TypeData.SchemaType == SchemaTypes.Array && elem.TypeData.ListItemTypeData.SchemaType == SchemaTypes.XmlNode)
)
throw new InvalidOperationException ("XmlText cannot be used to encode complex types");
if (elem.TypeData.IsComplexType)
elem.MappedType = ImportTypeMapping (defaultType, null, defaultNamespace);
elem.IsTextElement = true;
elem.WrappedElement = false;
list.Add (elem);
}
}
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 ("System.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);
}
private XmlTypeMapMember CreateMapMember (Type declaringType, XmlReflectionMember rmember, string defaultNamespace)
{
XmlTypeMapMember mapMember;
XmlAttributes atts = rmember.XmlAttributes;
TypeData typeData = TypeTranslator.GetTypeData (rmember.MemberType);
if (atts.XmlArray != null) {
if (atts.XmlArray.Namespace != null && atts.XmlArray.Form == XmlSchemaForm.Unqualified)
throw new InvalidOperationException ("XmlArrayAttribute.Form must not be Unqualified when it has an explicit Namespace value.");
if (typeData.SchemaType != SchemaTypes.Array &&
!(typeData.SchemaType == SchemaTypes.Primitive && typeData.Type == typeof (byte [])))
throw new InvalidOperationException ("XmlArrayAttribute can be applied to members of array or collection type.");
}
#if !MOONLIGHT
if (atts.XmlAnyAttribute != null)
{
if ( (rmember.MemberType.FullName == "System.Xml.XmlAttribute[]") ||
(rmember.MemberType.FullName == "System.Xml.XmlNode[]") )
{
mapMember = new XmlTypeMapMemberAnyAttribute();
}
else
throw new InvalidOperationException ("XmlAnyAttributeAttribute can only be applied to members of type XmlAttribute[] or XmlNode[]");
}
else
#endif
if (atts.XmlAnyElements != null && atts.XmlAnyElements.Count > 0)
{
// no XmlNode type check is done here (seealso: bug #553032).
XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement();
member.ElementInfo = ImportAnyElementInfo (defaultNamespace, rmember, member, atts);
mapMember = member;
}
else if (atts.Xmlns)
{
XmlTypeMapMemberNamespaces mapNamespaces = new XmlTypeMapMemberNamespaces ();
mapMember = mapNamespaces;
}
else if (atts.XmlAttribute != null)
{
// An attribute
if (atts.XmlElements != null && atts.XmlElements.Count > 0)
throw new Exception ("XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member");
XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute ();
if (atts.XmlAttribute.AttributeName.Length == 0)
mapAttribute.AttributeName = rmember.MemberName;
else
mapAttribute.AttributeName = atts.XmlAttribute.AttributeName;
mapAttribute.AttributeName = XmlConvert.EncodeLocalName (mapAttribute.AttributeName);
if (typeData.IsComplexType)
mapAttribute.MappedType = ImportTypeMapping (typeData.Type, null, defaultNamespace);
if (atts.XmlAttribute.Namespace != null && atts.XmlAttribute.Namespace != defaultNamespace)
{
if (atts.XmlAttribute.Form == XmlSchemaForm.Unqualified)
throw new InvalidOperationException ("The Form property may not be 'Unqualified' when an explicit Namespace property is present");
mapAttribute.Form = XmlSchemaForm.Qualified;
mapAttribute.Namespace = atts.XmlAttribute.Namespace;
}
else
{
mapAttribute.Form = atts.XmlAttribute.Form;
if (atts.XmlAttribute.Form == XmlSchemaForm.Qualified)
mapAttribute.Namespace = defaultNamespace;
else
mapAttribute.Namespace = "";
}
typeData = TypeTranslator.GetTypeData(rmember.MemberType, atts.XmlAttribute.DataType);
mapMember = mapAttribute;
}
else if (typeData.SchemaType == SchemaTypes.Array)
{
// If the member has a single XmlElementAttribute and the type is the type of the member,
// then it is not a flat list
if (atts.XmlElements.Count > 1 ||
(atts.XmlElements.Count == 1 && atts.XmlElements[0].Type != typeData.Type) ||
(atts.XmlText != null))
{
// A flat list
// check that it does not have XmlArrayAttribute
if (atts.XmlArray != null)
throw new InvalidOperationException ("XmlArrayAttribute cannot be used with members which also attributed with XmlElementAttribute or XmlTextAttribute.");
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.ListMap = new ListMap ();
member.ListMap.ItemInfo = ImportElementInfo (declaringType, XmlConvert.EncodeLocalName (rmember.MemberName), defaultNamespace, typeData.ListItemType, member, atts);
member.ElementInfo = member.ListMap.ItemInfo;
member.ListMap.ChoiceMember = member.ChoiceMember;
mapMember = member;
}
else
{
// A list
XmlTypeMapMemberList member = new XmlTypeMapMemberList ();
// Creates an ElementInfo that identifies the array instance.
member.ElementInfo = new XmlTypeMapElementInfoList();
XmlTypeMapElementInfo elem = new XmlTypeMapElementInfo (member, typeData);
elem.ElementName = XmlConvert.EncodeLocalName((atts.XmlArray != null && atts.XmlArray.ElementName.Length != 0) ? atts.XmlArray.ElementName : rmember.MemberName);
// note that it could be changed below (when Form is Unqualified)
elem.Namespace = (atts.XmlArray != null && atts.XmlArray.Namespace != null) ? atts.XmlArray.Namespace : defaultNamespace;
elem.MappedType = ImportListMapping (rmember.MemberType, null, elem.Namespace, atts, 0);
elem.IsNullable = (atts.XmlArray != null) ? atts.XmlArray.IsNullable : false;
elem.Form = (atts.XmlArray != null) ? atts.XmlArray.Form : XmlSchemaForm.Qualified;
// This is a bit tricky, but is done
// after filling descendant members, so
// that array items could be serialized
// with proper namespace.
if (atts.XmlArray != null && atts.XmlArray.Form == XmlSchemaForm.Unqualified)
elem.Namespace = String.Empty;
member.ElementInfo.Add (elem);
mapMember = member;
}
}
else
{
// An element
XmlTypeMapMemberElement member = new XmlTypeMapMemberElement ();
member.ElementInfo = ImportElementInfo (declaringType, XmlConvert.EncodeLocalName(rmember.MemberName), defaultNamespace, rmember.MemberType, member, atts);
mapMember = member;
}
mapMember.DefaultValue = GetDefaultValue (typeData, atts.XmlDefaultValue);
mapMember.TypeData = typeData;
mapMember.Name = rmember.MemberName;
mapMember.IsReturnValue = rmember.IsReturnValue;
return mapMember;
}
protected override void GenerateTextElementAttribute (CodeAttributeDeclarationCollection attributes, XmlTypeMapElementInfo einfo, TypeData defaultType)
{
CodeAttributeDeclaration uatt = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlTextAttribute");
if (einfo.TypeData.FullTypeName != defaultType.FullTypeName) uatt.Arguments.Add (GetTypeArg ("Type", einfo.TypeData.FullTypeName));
attributes.Add (uatt);
}
protected override void GenerateElementInfoMember (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, XmlTypeMapElementInfo einfo, TypeData defaultType, string defaultNamespace, bool addAlwaysAttr, bool forceUseMemberName)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.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);
}
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 (atts.SoapElement != null)
{
throw new Exception("SoapAttributeAttribute and SoapElementAttribute cannot be applied to the same member");
}
XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute();
if (atts.SoapAttribute.AttributeName == null)
{
mapAttribute.AttributeName = rmember.MemberName;
}
else
{
mapAttribute.AttributeName = 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;
}
else
{
if (typeData.SchemaType == SchemaTypes.Array)
{
mapMember = new XmlTypeMapMemberList();
}
else
{
mapMember = new XmlTypeMapMemberElement();
}
if (atts.SoapElement != null && atts.SoapElement.DataType != null)
{
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 = (atts.SoapElement != null && atts.SoapElement.ElementName != null) ? 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);
}
