* XmlCustomFormatter.cs: Fixed bug in serialization of chars. Support for byte[].
* XmlMapping.cs: Added internal property.
* XmlMemberMapping.cs, XmlMembersMapping.cs: Implemented.
* XmlReflectionImporter.cs: Implemented importing of XmlMembersMapping. Several fixes.
* XmlReflectionMember.cs: XmlAttributes are now created by default
* XmlSerializationReader.cs, XmlSerializationWriter.cs: Several fixes.
* XmlSerializationReaderInterpreter.cs, XmlSerializationWriterInterpreter.cs, XmlSerializer.cs:
Implemented support for XmlMembersMapping.
* XmlTypeMapping.cs: Property ObjectMap moved to XmlMapping.
svn path=/trunk/mcs/; revision=14997
+2003-05-29 Lluis Sanchez Gual <lluis@ximian.com>
+
+ * TypeData.cs, TypeTranslator.cs: Renamed some properties.
+ * XmlCustomFormatter.cs: Fixed bug in serialization of chars. Support for byte[].
+ * XmlMapping.cs: Added internal property.
+ * XmlMemberMapping.cs, XmlMembersMapping.cs: Implemented.
+ * XmlReflectionImporter.cs: Implemented importing of XmlMembersMapping. Several fixes.
+ * XmlReflectionMember.cs: XmlAttributes are now created by default
+ * XmlSerializationReader.cs, XmlSerializationWriter.cs: Several fixes.
+ * XmlSerializationReaderInterpreter.cs, XmlSerializationWriterInterpreter.cs, XmlSerializer.cs:
+ Implemented support for XmlMembersMapping.
+ * XmlTypeMapping.cs: Property ObjectMap moved to XmlMapping.
+
2003-05-28 Lluis Sanchez Gual <lluis@ximian.com>
* TypeData.cs, TypeTranslator.cs: Added support for enums. Added method for translating
}
}
- public string ElementName
+ public string TypeName
{
get {
- return elementName;
+ return type.Name;
}
}
- public string TypeName
+ public string XmlType
{
get {
- return type.Name;
+ return elementName;
}
}
primitiveTypes = new Hashtable();
ICollection types = nameCache.Values;
foreach (TypeData td in types)
- primitiveTypes.Add (td.ElementName, td);
+ primitiveTypes.Add (td.XmlType, td);
}
public static TypeData GetTypeData (Type type)
string name;
if (type.IsArray) {
- string sufix = GetTypeData (type.GetElementType ()).ElementName;
+ string sufix = GetTypeData (type.GetElementType ()).XmlType;
name = "ArrayOf" + Char.ToUpper (sufix [0]) + sufix.Substring (1);
}
else
//
// Author:
// John Donagher (john@webmeta.com)
+// Lluis Sanchez Gual (lluis@ximian.com)
//
// (C) 2002 John Donagher
//
-using System;\r
-\r
-namespace System.Xml.Serialization\r
-{\r
- /// <summary>\r
- /// Summary description for XmlMapping.\r
- /// </summary>\r
- public abstract class XmlMapping\r
- {\r
+using System;
+
+namespace System.Xml.Serialization
+{
+ public abstract class XmlMapping
+ {
+ ObjectMap map;
+
internal XmlMapping ()
{
}
- }\r
-}\r
+
+ internal ObjectMap ObjectMap
+ {
+ get { return map; }
+ set { map = value; }
+ }
+ }
+
+ internal class ObjectMap
+ {
+ }
+}
-// \r
-// System.Xml.Serialization.XmlMemberMapping\r
-//\r
-// Author:\r
-// Tim Coleman (tim@timcoleman.com)\r
-//\r
-// Copyright (C) Tim Coleman, 2002\r
-//\r
-\r
-namespace System.Xml.Serialization {\r
- public class XmlMemberMapping {\r
-\r
- internal XmlMemberMapping ()\r
- {\r
- }\r
-\r
- #region Properties\r
-\r
- public bool Any { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string ElementName { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string MemberName { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string Namespace {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string TypeFullName {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string TypeName {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string TypeNamespace {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- #endregion // Properties\r
- }\r
-}\r
+//
+// System.Xml.Serialization.XmlMemberMapping
+//
+// Author:
+// Tim Coleman (tim@timcoleman.com)
+// Lluis Sanchez Gual (lluis@ximian.com)
+//
+// Copyright (C) Tim Coleman, 2002
+//
+
+namespace System.Xml.Serialization
+{
+ public class XmlMemberMapping {
+
+ XmlTypeMapMember _mapMember;
+ string _elementName;
+ string _memberName;
+ string _namespace;
+ string _typeNamespace;
+
+ internal XmlMemberMapping (XmlReflectionMember rmember, XmlTypeMapMember mapMem)
+ {
+ _mapMember = mapMem;
+ _memberName = rmember.MemberName;
+
+ if (mapMem is XmlTypeMapMemberElement)
+ {
+ XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) ((XmlTypeMapMemberElement)mapMem).ElementInfo[0];
+ _elementName = info.ElementName;
+ _namespace = info.Namespace;
+ if (info.MappedType != null) _typeNamespace = info.MappedType.Namespace;
+ else _namespace = "";
+ }
+ else
+ {
+ _elementName = _memberName;
+ _namespace = "";
+ }
+
+ if (_typeNamespace == null) _typeNamespace = _namespace;
+ }
+
+ #region Properties
+
+ public bool Any {
+ [MonoTODO]
+ get { return false; }
+ }
+
+ public string ElementName {
+ get { return _elementName; }
+ }
+
+ public string MemberName {
+ get { return _memberName; }
+ }
+
+ public string Namespace {
+ get { return _namespace; }
+ }
+
+ public string TypeFullName {
+ get { return _mapMember.TypeData.FullTypeName; }
+ }
+
+ public string TypeName {
+ get { return _mapMember.TypeData.XmlType; }
+ }
+
+ public string TypeNamespace {
+ get { return _typeNamespace; }
+ }
+
+ internal XmlTypeMapMember TypeMapMember {
+ get { return _mapMember; }
+ }
+
+ #endregion // Properties
+ }
+}
-// \r
-// System.Xml.Serialization.XmlMembersMapping\r
-//\r
-// Author:\r
-// Tim Coleman (tim@timcoleman.com)\r
-//\r
-// Copyright (C) Tim Coleman, 2002\r
-//\r
-\r
-using System.Reflection;\r
-\r
-namespace System.Xml.Serialization {\r
- public class XmlMembersMapping : XmlMapping {\r
-\r
- internal XmlMembersMapping ()\r
- {\r
- }\r
-\r
- #region Properties\r
-\r
- public int Count { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string ElementName { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public XmlMemberMapping this [int index] { \r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string Namespace {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string TypeName {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- public string TypeNamespace {\r
- [MonoTODO]\r
- get { throw new NotImplementedException (); }\r
- }\r
-\r
- #endregion // Properties\r
- }\r
-}\r
+//
+// System.Xml.Serialization.XmlMembersMapping
+//
+// Author:
+// Tim Coleman (tim@timcoleman.com)
+// Lluis Sanchez Gual (lluis@ximian.com)
+//
+// Copyright (C) Tim Coleman, 2002
+//
+
+using System.Reflection;
+
+namespace System.Xml.Serialization {
+ public class XmlMembersMapping : XmlMapping {
+
+ string _elementName;
+ string _namespace;
+ bool _hasWrapperElement;
+ XmlMemberMapping[] _mapping;
+
+ internal XmlMembersMapping ()
+ {
+ }
+
+ internal XmlMembersMapping (string elementName, string ns, bool hasWrapperElement, XmlMemberMapping[] mapping)
+ {
+ _elementName = elementName;
+ _namespace = ns;
+ _hasWrapperElement = hasWrapperElement;
+ _mapping = mapping;
+
+ ClassMap map = new ClassMap ();
+ foreach (XmlMemberMapping mm in mapping)
+ map.AddMember (mm.TypeMapMember);
+ ObjectMap = map;
+ }
+
+ #region Properties
+
+ public int Count {
+ get { return _mapping.Length; }
+ }
+
+ public string ElementName {
+ get { return _elementName; }
+ }
+
+ public XmlMemberMapping this [int index] {
+ get { return _mapping[index]; }
+ }
+
+ public string Namespace {
+ get { return _namespace; }
+ }
+
+ public string TypeName {
+ [MonoTODO]
+ get { throw new NotImplementedException (); }
+ }
+
+ public string TypeNamespace {
+ [MonoTODO]
+ get { throw new NotImplementedException (); }
+ }
+
+ internal bool HasWrapperElement {
+ get { return _hasWrapperElement; }
+ }
+
+ #endregion // Properties
+ }
+}
#region Methods
- [MonoTODO]
public XmlMembersMapping ImportMembersMapping (string elementName,
string ns,
XmlReflectionMember [] members,
bool hasWrapperElement)
{
- throw new NotImplementedException ();
+ XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
+ for (int n=0; n<members.Length; n++)
+ {
+ XmlTypeMapMember mapMem = CreateMapMember (members[n], ns);
+ mapping[n] = new XmlMemberMapping (members[n], mapMem);
+ }
+ return new XmlMembersMapping (elementName, ns, hasWrapperElement, mapping);
}
public XmlTypeMapping ImportTypeMapping (Type type)
string membersNamespace = defaultNamespace;
string elementName;
XmlAttributes atts = null;
- if (defaultXmlType == null) defaultXmlType = typeData.ElementName;
+ if (defaultXmlType == null) defaultXmlType = typeData.XmlType;
if (!typeData.IsListType)
{
RegisterClrType (map, type, defaultNamespace);
RegisterSchemaType (map, map.XmlType, defaultNamespace);
- map.ObjectMap = new ClassMap ();
+ ClassMap classMap = new ClassMap ();
+ map.ObjectMap = classMap;
// Import members
- ICollection members = GetReflectionMembers (type);
- foreach (XmlReflectionMember rmember in members)
+ try
{
- if (rmember.XmlAttributes.XmlIgnore) continue;
- AddMember (map, rmember, map.Namespace);
+ ICollection members = GetReflectionMembers (type);
+ foreach (XmlReflectionMember rmember in members)
+ {
+ if (rmember.XmlAttributes.XmlIgnore) continue;
+ classMap.AddMember (CreateMapMember (rmember, map.Namespace));
+ }
+ }
+ catch (Exception ex) {
+ throw CreateError (map, ex.Message);
}
// Import derived classes
if (att.ElementName != null) elem.ElementName = att.ElementName;
else if (elem.MappedType != null) elem.ElementName = elem.MappedType.ElementName;
- else elem.ElementName = TypeTranslator.GetTypeData(elemType).ElementName;
+ else elem.ElementName = TypeTranslator.GetTypeData(elemType).XmlType;
list.Add (elem);
}
elem.MappedType = ImportTypeMapping (itemType, null, defaultNamespace);
if (elem.MappedType != null) elem.ElementName = elem.MappedType.ElementName;
- else elem.ElementName = TypeTranslator.GetTypeData(itemType).ElementName ;
+ else elem.ElementName = TypeTranslator.GetTypeData(itemType).XmlType ;
elem.Namespace = (defaultNamespace != null) ? defaultNamespace : "";
elem.IsNullable = true; // By default, items are nullable
return members;
}
- private void AddMember (XmlTypeMapping map, XmlReflectionMember rmember, string defaultNamespace)
+ private XmlTypeMapMember CreateMapMember (XmlReflectionMember rmember, string defaultNamespace)
{
XmlTypeMapMember mapMember;
XmlAttributes atts = rmember.XmlAttributes;
// An attribute
if (atts.XmlElements != null && atts.XmlElements.Count > 0)
- throw CreateError (map, "XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member");
+ throw new Exception ("XmlAttributeAttribute and XmlElementAttribute cannot be applied to the same member");
XmlTypeMapMemberAttribute mapAttribute = new XmlTypeMapMemberAttribute ();
if (atts.XmlAttribute.AttributeName == null)
mapMember.TypeData = typeData;
mapMember.Name = rmember.MemberName;
- ((ClassMap)map.ObjectMap).AddMember (mapMember);
+ return mapMember;
}
XmlTypeMapElementInfoList ImportElementInfo (string defaultName, string defaultNamespace, Type defaultType, XmlTypeMapMemberElement member, XmlAttributes atts)
list.Add (elem);
}
+ bool multiType = (atts.XmlElements.Count > 1);
foreach (XmlElementAttribute att in atts.XmlElements)
{
Type elemType = (att.Type != null) ? att.Type : defaultType;
elem.IsNullable = att.IsNullable;
if (elem.TypeData.IsComplexType)
elem.MappedType = ImportTypeMapping (elemType, null, elem.Namespace);
+
+ if (att.ElementName != null)
+ elem.ElementName = 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;
+
list.Add (elem);
}
return list;
Exception CreateError (XmlTypeMapping map, string message)
{
- throw new InvalidOperationException ("There was an error reflecting '" + map.TypeFullName + "': " + message);
+ return new InvalidOperationException ("There was an error reflecting '" + map.TypeFullName + "': " + message);
}
#endregion // Methods
}\r
\r
public SoapAttributes SoapAttributes {\r
- get { return soapAttributes; }\r
+ get { \r
+ if (soapAttributes == null) soapAttributes = new SoapAttributes();\r
+ return soapAttributes; \r
+ }\r
set { soapAttributes = value; }\r
}\r
\r
public XmlAttributes XmlAttributes {\r
- get { return xmlAttributes; }\r
+ get { \r
+ if (xmlAttributes == null) xmlAttributes = new XmlAttributes();\r
+ return xmlAttributes; \r
+ }\r
set { xmlAttributes = value; }\r
}\r
\r
protected XmlQualifiedName GetXsiType ()
{
string typeName = Reader.GetAttribute ("xsi:type");
- if (typeName == string.Empty) return null;
+ if (typeName == string.Empty || typeName == null) return null;
int i = typeName.IndexOf (":");
if (i == -1) return new XmlQualifiedName (typeName, "");
else
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
- {
UnknownNode (null);
- reader.Read ();
- }
+
ReadEndElement ();
return true;
}
protected void UnknownNode (object o)
{
// TODO: line numbers
- if (Reader.NodeType == XmlNodeType.Element) Reader.Skip();
eventSource.OnUnknownNode (new XmlNodeEventArgs(0, 0, Reader.LocalName, Reader.Name, Reader.NamespaceURI, Reader.NodeType, o, Reader.Value));
+ if (Reader.NodeType != XmlNodeType.Attribute)
+ {
+ Reader.Skip();
+ if (Reader.ReadState == ReadState.EndOfFile)
+ throw new InvalidOperationException ("End of document found");
+ }
}
protected void UnreferencedObject (string id, object o)
{
public class XmlSerializationReaderInterpreter: XmlSerializationReader
{
- XmlTypeMapping _typeMap;
+ XmlMapping _typeMap;
- public XmlSerializationReaderInterpreter(XmlTypeMapping typeMap)
+ public XmlSerializationReaderInterpreter(XmlMapping typeMap)
{
_typeMap = typeMap;
}
internal override object ReadObject ()
{
Reader.MoveToContent();
- return ReadObject (_typeMap, true, true);
+ if (_typeMap is XmlTypeMapping)
+ return ReadObject ((XmlTypeMapping)_typeMap, true, true);
+ else
+ return ReadMessage ((XmlMembersMapping)_typeMap);
+ }
+
+ object ReadMessage (XmlMembersMapping typeMap)
+ {
+ object[] parameters = new object[typeMap.Count];
+
+ if (typeMap.HasWrapperElement)
+ {
+ while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
+ {
+ if (Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace))
+ {
+ if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }
+ Reader.ReadStartElement();
+ ReadMembers ((ClassMap)typeMap.ObjectMap, parameters, true);
+ ReadEndElement();
+ break;
+ }
+ else
+ UnknownNode(null);
+
+ Reader.MoveToContent();
+ }
+ }
+ else
+ ReadMembers ((ClassMap)typeMap.ObjectMap, parameters, true);
+
+ return parameters;
}
object ReadObject (XmlTypeMapping typeMap, bool isNullable, bool checkType)
}
object ob = Activator.CreateInstance (typeMap.TypeData.Type);
- Type obType = typeMap.TypeData.Type;
- ClassMap map = (ClassMap) typeMap.ObjectMap;
- // Reads attributes
+ Reader.MoveToElement();
+ bool isEmpty = Reader.IsEmptyElement;
+ ReadMembers ((ClassMap) typeMap.ObjectMap, ob, false);
- XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
- int anyAttributeIndex = 0;
- object anyAttributeArray = null;
+ if (isEmpty) Reader.Skip();
+ else ReadEndElement();
+
+ return ob;
+ }
- while (Reader.MoveToNextAttribute())
+ void ReadMembers (ClassMap map, object ob, bool isValueList)
+ {
+ // A value list cannot have attributes
+
+ if (!isValueList)
{
- XmlTypeMapMemberAttribute member = map.GetAttribute (Reader.LocalName, Reader.NamespaceURI);
+ // Reads attributes
+
+ XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
+ int anyAttributeIndex = 0;
+ object anyAttributeArray = null;
- if (member != null) {
- member.SetValue (ob, XmlCustomFormatter.FromXmlString (member.TypeData.Type, Reader.Value));
+ while (Reader.MoveToNextAttribute())
+ {
+ XmlTypeMapMemberAttribute member = map.GetAttribute (Reader.LocalName, Reader.NamespaceURI);
+
+ if (member != null)
+ {
+ SetMemberValue (member, ob, XmlCustomFormatter.FromXmlString (member.TypeData.Type, Reader.Value), isValueList);
+ }
+ else if (IsXmlnsAttribute(Reader.Name))
+ {
+ // Ignore
+ }
+ else if (anyAttrMember != null)
+ {
+ AddListValue (anyAttrMember.TypeData.Type, ref anyAttributeArray, anyAttributeIndex++, Document.ReadNode(Reader), true);
+ }
+ else
+ UnknownNode(ob);
}
- else if (IsXmlnsAttribute(Reader.Name)) {
- // Ignore
- }
- else if (anyAttrMember != null) {
- AddListValue (anyAttrMember.TypeData.Type, ref anyAttributeArray, anyAttributeIndex++, Document.ReadNode(Reader), true);
+
+ if (anyAttrMember != null)
+ {
+ anyAttributeArray = ShrinkArray ((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
+ SetMemberValue (anyAttrMember, ob, anyAttributeArray, isValueList);
}
- else
- UnknownNode(ob);
- }
- if (anyAttrMember != null)
- {
- anyAttributeArray = ShrinkArray ((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
- anyAttrMember.SetValue (ob, anyAttributeArray);
+ Reader.MoveToElement();
+ if (Reader.IsEmptyElement)
+ return;
+
+ Reader.ReadStartElement();
}
// Reads elements
- Reader.MoveToElement();
- if (Reader.IsEmptyElement)
- {
- Reader.Skip();
- return ob;
- }
-
bool[] readFlag = new bool[map.ElementMembers.Count];
- Reader.ReadStartElement();
Reader.MoveToContent();
int[] indexes = null;
indexes = new int[map.FlatLists.Count];
flatLists = new object[map.FlatLists.Count];
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
- if (mem.IsReadOnly (obType)) flatLists[mem.FlatArrayIndex] = mem.GetValue (ob);
+ if (IsReadOnly (mem, ob, isValueList)) flatLists[mem.FlatArrayIndex] = mem.GetValue (ob);
}
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
{
- if (info.Member.IsReadOnly (obType)) ReadListElement (info.MappedType, info.IsNullable, info.Member.GetValue (ob), false);
- else info.Member.SetValue (ob, ReadListElement (info.MappedType, info.IsNullable, null, true));
+ if (IsReadOnly (info.Member, ob, isValueList)) ReadListElement (info.MappedType, info.IsNullable, info.Member.GetValue (ob), 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.Type, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement (info), !info.Member.IsReadOnly (obType));
+ AddListValue (mem.TypeData.Type, 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.Type, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (false), true);
- else mem.SetValue (ob, ReadXmlNode (false));
+ else SetMemberValue (mem, ob, ReadXmlNode (false), isValueList);
}
else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
{
- info.Member.SetValue (ob, ReadObjectElement (info));
+ SetMemberValue (info.Member, ob, ReadObjectElement (info), isValueList);
readFlag[info.Member.Index] = true;
}
else
{
XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
if (mem.TypeData.IsListType) AddListValue (mem.TypeData.Type, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (false), true);
- else mem.SetValue (ob, ReadXmlNode (false));
+ else SetMemberValue (mem, ob, ReadXmlNode (false), isValueList);
}
else
UnknownNode(ob);
Object list = flatLists[mem.FlatArrayIndex];
if (mem.TypeData.Type.IsArray)
list = ShrinkArray ((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true);
- if (!mem.IsReadOnly (obType))
- mem.SetValue (ob, list);
+ if (!IsReadOnly (mem, ob, isValueList))
+ SetMemberValue (mem, ob, list, isValueList);
}
- }
+ }
+ }
- ReadEndElement();
- return ob;
+ bool IsReadOnly (XmlTypeMapMember member, object ob, bool isValueList)
+ {
+ if (isValueList) return false;
+ else return member.IsReadOnly (ob.GetType());
+ }
+
+ void SetMemberValue (XmlTypeMapMember member, object ob, object value, bool isValueList)
+ {
+ if (isValueList) ((object[])ob)[member.Index] = value;
+ else member.SetValue (ob, value);
}
object ReadObjectElement (XmlTypeMapElementInfo elem)
object ReadEnumElement (XmlTypeMapping typeMap, bool isNullable)
{
- Reader.ReadStartElement ();\r
- object o = GetEnumValue (typeMap, Reader.ReadString());\r
- Reader.ReadEndElement ();\r
- return o;\r
+ Reader.ReadStartElement ();
+ object o = GetEnumValue (typeMap, Reader.ReadString());
+ Reader.ReadEndElement ();
+ return o;
}
object GetEnumValue (XmlTypeMapping typeMap, string val)
protected void WriteStartDocument ()
{
- Writer.WriteStartDocument ();
+ if (Writer.WriteState == WriteState.Start)
+ Writer.WriteStartDocument ();
}
protected void WriteStartElement (string name)
TypeData td = TypeTranslator.GetTypeData (o.GetType ());
if (td.SchemaType != SchemaTypes.Primitive)
throw new InvalidOperationException ("Invalid type: " + o.GetType().FullName);
- WriteXsiType (td.ElementName, XmlSchema.Namespace);
+ WriteXsiType (td.XmlType, XmlSchema.Namespace);
}
WriteValue (value);
{
internal class XmlSerializationWriterInterpreter: XmlSerializationWriter
{
- XmlTypeMapping _typeMap;
+ XmlMapping _typeMap;
- public XmlSerializationWriterInterpreter(XmlTypeMapping typeMap)
+ public XmlSerializationWriterInterpreter(XmlMapping typeMap)
{
_typeMap = typeMap;
}
internal override void WriteObject (object ob)
{
- WriteObject (_typeMap, ob, _typeMap.ElementName, _typeMap.Namespace, true, false);
+ WriteStartDocument ();
+
+ if (_typeMap is XmlTypeMapping)
+ {
+ XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
+ WriteObject (mp, ob, mp.ElementName, mp.Namespace, true, false);
+ }
+ else if (ob is object[])
+ WriteMessage ((XmlMembersMapping)_typeMap, (object[]) ob);
+ else
+ throw CreateUnknownTypeException (ob);
}
void WriteObject (XmlTypeMapping typeMap, object ob, string element, string namesp, bool isNullable, bool needType)
}
}
+ void WriteMessage (XmlMembersMapping membersMap, object[] parameters)
+ {
+ if (membersMap.HasWrapperElement) {
+ WriteStartDocument();\r
+ // TopLevelElement();\r
+ WriteStartElement(membersMap.ElementName, membersMap.Namespace);\r
+ }\r
+ \r
+ WriteMembers ((ClassMap)membersMap.ObjectMap, parameters, true);\r
+\r
+ if (membersMap.HasWrapperElement)
+ WriteEndElement();
+ }
+
void WriteObjectElement (XmlTypeMapping typeMap, object ob, string element, string namesp, bool needType)
{
WriteStartElement(element, namesp, ob);
if (needType)
WriteXsiType(typeMap.XmlType, typeMap.Namespace);
+ ClassMap map = (ClassMap)typeMap.ObjectMap;
+ WriteMembers (map, ob, false);
+ WriteEndElement (ob);
+ }
+
+ void WriteMembers (ClassMap map, object ob, bool isValueList)
+ {
// Write attributes
- ClassMap map = (ClassMap)typeMap.ObjectMap;
ICollection attributes = map.AttributeMembers;
if (attributes != null)
{
- foreach (XmlTypeMapMemberAttribute attr in attributes)
- WriteAttribute(attr.AttributeName, attr.Namespace, XmlCustomFormatter.ToXmlString (attr.GetValue(ob)));
+ foreach (XmlTypeMapMemberAttribute attr in attributes) {
+ if (MemberHasValue (attr, ob, isValueList))
+ WriteAttribute(attr.AttributeName, attr.Namespace, XmlCustomFormatter.ToXmlString (GetMemberValue (attr, ob, isValueList)));
+ }
}
- if (map.DefaultAnyAttributeMember != null)
+ XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
+ if (anyAttrMember != null && MemberHasValue (anyAttrMember, ob, isValueList))
{
- ICollection extraAtts = (ICollection) map.DefaultAnyAttributeMember.GetValue (ob);
- if (extraAtts != null) {
+ ICollection extraAtts = (ICollection) GetMemberValue (anyAttrMember, ob, isValueList);
+ if (extraAtts != null) \r
+ {
foreach (XmlAttribute attr in extraAtts)
WriteAttribute(attr.LocalName, attr.NamespaceURI, attr.Value);
}
{
foreach (XmlTypeMapMemberElement member in members)
{
- object memberValue = member.GetValue (ob);
- if (member.GetType() == typeof(XmlTypeMapMemberList))
+ if (!MemberHasValue (member, ob, isValueList)) continue;
+ object memberValue = GetMemberValue (member, ob, isValueList);
+ Type memType = member.GetType();
+
+ if (memType == typeof(XmlTypeMapMemberList))
{
if (memberValue != null) \r
{
WriteEndElement (memberValue);
}
}
- else if (member.GetType() == typeof(XmlTypeMapMemberFlatList))
+ else if (memType == typeof(XmlTypeMapMemberFlatList))
{
if (memberValue != null)
WriteListContent (member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue);
}
- else if (member.GetType() == typeof(XmlTypeMapMemberAnyElement))
+ else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
if (memberValue != null)
WriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
}
- else if (member.GetType() == typeof(XmlTypeMapMemberAnyElement))
+ else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
if (memberValue != null)
WriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
}
- else if (member.GetType() == typeof(XmlTypeMapMemberAnyAttribute))
+ else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
{
// Ignore
}
- else if (member.GetType() == typeof(XmlTypeMapMemberElement))
+ else if (memType == typeof(XmlTypeMapMemberElement))
{
XmlTypeMapElementInfo elem = member.FindElement (ob, memberValue);
WriteMemberElement (elem, memberValue);
}
else
throw new InvalidOperationException ("Unknown member type");
- }
- }
- WriteEndElement (ob);
+ }\r
+ }\r
+ }
+
+ object GetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
+ {
+ if (isValueList) return ((object[])ob)[member.Index];
+ else return member.GetValue (ob);
+ }
+
+ bool MemberHasValue (XmlTypeMapMember member, object ob, bool isValueList)
+ {
+ if (isValueList) return member.Index < ((object[])ob).Length;
+ else return true;
}
void WriteMemberElement (XmlTypeMapElementInfo elem, object memberValue)
#region Fields
- XmlTypeMapping typeMapping;
+ XmlMapping typeMapping;
#endregion // Fields
typeMapping = xmlTypeMapping;
}
+ internal XmlSerializer (XmlMapping mapping)
+ {
+ typeMapping = mapping;
+ }
+
public XmlSerializer (Type type, string defaultNamespace)
: this (type, null, null, null, defaultNamespace)
{
typeMapping = importer.ImportTypeMapping (type, root, defaultNamespace);
}
+
#endregion // Constructors
#region Events
public virtual bool CanDeserialize (XmlReader xmlReader)
{
xmlReader.MoveToContent ();
- return typeMapping.ElementName == xmlReader.LocalName;
+ if (typeMapping is XmlMembersMapping)
+ return true;
+ else
+ return ((XmlTypeMapping)typeMapping).ElementName == xmlReader.LocalName;
}
protected virtual XmlSerializationReader CreateReader ()
{
XmlSerializer [] sers = new XmlSerializer [mappings.Length];
for (int n=0; n<mappings.Length; n++)
- {
- XmlTypeMapping map = mappings[n] as XmlTypeMapping;
- if (map == null) throw new NotSupportedException ("Unsupported mapping type");
- sers[n] = new XmlSerializer (map);
- }
+ sers[n] = new XmlSerializer (mappings[n]);
return sers;
}
public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
{
- writer.WriteStartDocument ();
XmlSerializationWriter xsWriter = CreateWriter ();
xsWriter.Initialize (writer);
Serialize (o, xsWriter);
- writer.WriteEndDocument();
writer.Flush ();
}
#endregion // Methods
private string ns;\r
private string xmlType;\r
TypeData type;\r
- ObjectMap map;\r
\r
ArrayList _derivedTypes = new ArrayList();\r
\r
if (map.xmlType == name && map.ns == ens) return map;\r
return null;\r
}\r
-\r
- internal ObjectMap ObjectMap\r
- {\r
- get { return map; }\r
- set { map = value; }\r
- }\r
}\r
\r
- internal class ObjectMap\r
- {\r
- }\r
-\r
-\r
// Mapping info for classes and structs\r
\r
internal class ClassMap: ObjectMap\r
projects / mono.git / commitdiff