mcs/class/System.XML/System.Xml.Serialization/XmlSerializationReaderInterpreter.cs

   1 //
   2 // XmlSerializationReaderInterpreter.cs:
   3 //
   4 // Author:
   5 //   Lluis Sanchez Gual (lluis@ximian.com)
   6 //
   7 // (C) 2002, 2003 Ximian, Inc.  http://www.ximian.com
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System;
  32 using System.Reflection;
  33 using System.Collections;
  34
  35 namespace System.Xml.Serialization
  36 {
  37         internal class XmlSerializationReaderInterpreter: XmlSerializationReader
  38         {
  39                 XmlMapping _typeMap;
  40                 SerializationFormat _format;
  41                 static readonly XmlQualifiedName AnyType = new XmlQualifiedName("anyType", System.Xml.Schema.XmlSchema.Namespace);
  42                 static readonly object [] empty_array = new object [0];
  43
  44                 public XmlSerializationReaderInterpreter(XmlMapping typeMap)
  45                 {
  46                         _typeMap = typeMap;
  47                         _format = typeMap.Format;
  48                 }
  49
  50                 protected override void InitCallbacks ()
  51                 {
  52                         ArrayList maps = _typeMap.RelatedMaps;
  53                         if (maps != null)
  54                         {
  55                                 foreach (XmlTypeMapping map in maps)
  56                                 {
  57                                         if (map.TypeData.SchemaType == SchemaTypes.Class || map.TypeData.SchemaType == SchemaTypes.Enum)
  58                                         {
  59                                                 ReaderCallbackInfo info = new ReaderCallbackInfo (this, map);
  60                                                 AddReadCallback (map.XmlType, map.Namespace, map.TypeData.Type, new XmlSerializationReadCallback (info.ReadObject));
  61                                         }
  62                                 }
  63                         }
  64                 }
  65
  66                 protected override void InitIDs ()
  67                 {
  68                 }
  69
  70                 protected XmlTypeMapping GetTypeMap (Type type)
  71                 {
  72                         ArrayList maps = _typeMap.RelatedMaps;
  73                         if (maps != null)
  74                         {
  75                                 foreach (XmlTypeMapping map in maps)
  76                                         if (map.TypeData.Type == type) return map;
  77                         }
  78                         throw new InvalidOperationException ("Type " + type + " not mapped");
  79                 }
  80
  81                 public object ReadRoot ()
  82                 {
  83                         Reader.MoveToContent();
  84                         if (_typeMap is XmlTypeMapping)
  85                         {
  86                                 if (_format == SerializationFormat.Literal)
  87                                         return ReadRoot ((XmlTypeMapping)_typeMap);
  88                                 else
  89                                         return ReadEncodedObject ((XmlTypeMapping)_typeMap);
  90                         }
  91                         else
  92                                 return ReadMessage ((XmlMembersMapping)_typeMap);
  93                 }
  94
  95                 object ReadEncodedObject (XmlTypeMapping typeMap)
  96                 {
  97 #if MOONLIGHT
  98                         throw new NotSupportedException ();
  99 #else
 100                         object ob = null;
 101                         Reader.MoveToContent();
 102                         if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 103                         {
 104                                 if (Reader.LocalName == typeMap.ElementName && Reader.NamespaceURI == typeMap.Namespace)
 105                                         ob = ReadReferencedElement();
 106                                 else
 107                                         throw CreateUnknownNodeException();
 108                         }
 109                         else
 110                                 UnknownNode(null);
 111
 112                         ReadReferencedElements();
 113                         return ob;
 114 #endif
 115                 }
 116
 117                 protected virtual object ReadMessage (XmlMembersMapping typeMap)
 118                 {
 119 #if MOONLIGHT
 120                         throw new NotSupportedException ();
 121 #else
 122                         object[] parameters = new object[typeMap.Count];
 123
 124                         if (typeMap.HasWrapperElement)
 125                         {
 126                                 // bug #79988: out parameters need to be initialized if they
 127                                 // are value types
 128                                 ArrayList members = ((ClassMap) typeMap.ObjectMap).AllMembers;
 129                                 for (int n = 0; n < members.Count; n++) {
 130                                         XmlTypeMapMember mem = (XmlTypeMapMember) members [n];
 131                                         if (!mem.IsReturnValue && mem.TypeData.IsValueType)
 132                                                 SetMemberValueFromAttr (mem, parameters, CreateInstance (
 133                                                         mem.TypeData.Type), true);
 134                                 }
 135
 136                                 if (_format == SerializationFormat.Encoded)
 137                                 {
 138                                         while (Reader.NodeType == System.Xml.XmlNodeType.Element)
 139                                         {
 140                                                 string root = Reader.GetAttribute ("root", XmlSerializer.EncodingNamespace);
 141                                                 if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;
 142                                                 ReadReferencedElement ();
 143                                                 Reader.MoveToContent ();
 144                                         }
 145                                 }
 146
 147                                 while (Reader.NodeType != System.Xml.XmlNodeType.EndElement &&
 148                                        // it could be an empty root element
 149                                        Reader.ReadState == ReadState.Interactive)
 150                                 {
 151                                         if (Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace)
 152                                             || _format == SerializationFormat.Encoded)
 153                                         {
 154                                                 ReadAttributeMembers ((ClassMap)typeMap.ObjectMap, parameters, true);
 155                                                 if (Reader.IsEmptyElement) {
 156                                                         Reader.Skip();
 157                                                         Reader.MoveToContent();
 158                                                         continue;
 159                                                 }
 160                                                 Reader.ReadStartElement();
 161                                                 ReadMembers ((ClassMap)typeMap.ObjectMap, parameters, true, false);
 162                                                 ReadEndElement();
 163                                                 break;
 164                                         }
 165                                         else
 166                                                 UnknownNode(null);
 167
 168                                         Reader.MoveToContent();
 169                                 }
 170                         }
 171                         else
 172                                 ReadMembers ((ClassMap)typeMap.ObjectMap, parameters, true, _format == SerializationFormat.Encoded);
 173
 174                         if (_format == SerializationFormat.Encoded)
 175                                 ReadReferencedElements();
 176
 177                         return parameters;
 178 #endif
 179                 }
 180
 181                 object ReadRoot (XmlTypeMapping rootMap)
 182                 {
 183                         if (rootMap.TypeData.SchemaType == SchemaTypes.XmlNode)
 184                         {
 185                                 return ReadXmlNodeElement (rootMap, true);
 186                         }
 187                         else
 188                         {
 189                                 if (Reader.LocalName != rootMap.ElementName || Reader.NamespaceURI != rootMap.Namespace)
 190                                         throw CreateUnknownNodeException();
 191
 192                                 return ReadObject (rootMap, rootMap.IsNullable, true);
 193                         }
 194                 }
 195
 196
 197                 protected virtual object ReadObject (XmlTypeMapping typeMap, bool isNullable, bool checkType)
 198                 {
 199                         switch (typeMap.TypeData.SchemaType)
 200                         {
 201                                 case SchemaTypes.Class: return ReadClassInstance (typeMap, isNullable, checkType);
 202                                 case SchemaTypes.Array: return ReadListElement (typeMap, isNullable, null, true);
 203                                 case SchemaTypes.XmlNode: return ReadXmlNodeElement (typeMap, isNullable);
 204                                 case SchemaTypes.Primitive: return ReadPrimitiveElement (typeMap, isNullable);
 205                                 case SchemaTypes.Enum: return ReadEnumElement (typeMap, isNullable);
 206                                 case SchemaTypes.XmlSerializable: return ReadXmlSerializableElement (typeMap, isNullable);
 207                                 default: throw new Exception ("Unsupported map type");
 208                         }
 209                 }
 210
 211                 protected virtual object ReadClassInstance (XmlTypeMapping typeMap, bool isNullable, bool checkType)
 212                 {
 213                         if (isNullable && ReadNull()) return null;
 214
 215                         if (checkType)
 216                         {
 217                 System.Xml.XmlQualifiedName t = GetXsiType();
 218                                 if (t != null)
 219                                 {
 220                                         XmlTypeMapping realMap = typeMap.GetRealElementMap (t.Name, t.Namespace);
 221                                         if (realMap == null) {
 222                                                 if (typeMap.TypeData.Type == typeof(object))
 223                                                         return ReadTypedPrimitive (t);
 224                                                 else
 225                                                         throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)t);
 226                                         }
 227                                         if (realMap != typeMap)
 228                                                 return ReadObject (realMap, false, false);
 229                                 }
 230                                 else if (typeMap.TypeData.Type == typeof(object))
 231                                         return ReadTypedPrimitive (AnyType);
 232             }
 233
 234                         object ob = CreateInstance (typeMap.TypeData.Type, true);
 235
 236                         Reader.MoveToElement();
 237                         bool isEmpty = Reader.IsEmptyElement;
 238                         ReadClassInstanceMembers (typeMap, ob);
 239
 240                         if (isEmpty) Reader.Skip();
 241                         else ReadEndElement();
 242
 243                         return ob;
 244                 }
 245
 246                 protected virtual void ReadClassInstanceMembers (XmlTypeMapping typeMap, object ob)
 247                 {
 248                         ReadMembers ((ClassMap) typeMap.ObjectMap, ob, false, false);
 249                 }
 250
 251                 void ReadAttributeMembers (ClassMap map, object ob, bool isValueList)
 252                 {
 253                         XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
 254                         int anyAttributeIndex = 0;
 255                         object anyAttributeArray = null;
 256
 257                         while (Reader.MoveToNextAttribute())
 258                         {
 259                                 XmlTypeMapMemberAttribute member = map.GetAttribute (Reader.LocalName, Reader.NamespaceURI);
 260
 261                                 if (member != null)
 262                                 {
 263                                         SetMemberValue (member, ob, GetValueFromXmlString (Reader.Value, member.TypeData, member.MappedType), isValueList);
 264                                 }
 265                                 else if (IsXmlnsAttribute(Reader.Name))
 266                                 {
 267                                         // If the map has NamespaceDeclarations,
 268                                         // then store this xmlns to the given member.
 269                                         // If the instance doesn't exist, then create.
 270                                         if (map.NamespaceDeclarations != null) {
 271                                                 XmlSerializerNamespaces nss = this.GetMemberValue (map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces;
 272                                                 if (nss == null) {
 273                                                         nss = new XmlSerializerNamespaces ();
 274                                                         SetMemberValue (map.NamespaceDeclarations, ob, nss, isValueList);
 275                                                 }
 276                                                 if (Reader.Prefix == "xmlns")
 277                                                         nss.Add (Reader.LocalName, Reader.Value);
 278                                                 else
 279                                                         nss.Add ("", Reader.Value);
 280                                         }
 281                                 }
 282 #if !MOONLIGHT
 283                                 else if (anyAttrMember != null)
 284                                 {
 285                                         XmlAttribute attr = (XmlAttribute) Document.ReadNode(Reader);
 286                                         ParseWsdlArrayType (attr);
 287                                         AddListValue (anyAttrMember.TypeData, ref anyAttributeArray, anyAttributeIndex++, attr, true);
 288                                 }
 289                                 else
 290                                         ProcessUnknownAttribute(ob);
 291 #endif
 292                         }
 293
 294 #if !MOONLIGHT
 295                         if (anyAttrMember != null)
 296                         {
 297                                 anyAttributeArray = ShrinkArray ((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
 298                                 SetMemberValue (anyAttrMember, ob, anyAttributeArray, isValueList);
 299                         }
 300 #endif
 301                         Reader.MoveToElement ();
 302                 }
 303
 304                 void ReadMembers (ClassMap map, object ob, bool isValueList, bool readBySoapOrder)
 305                 {
 306                         // Reads attributes
 307                         ReadAttributeMembers (map, ob, isValueList);
 308
 309                         if (!isValueList)
 310                         {
 311                                 Reader.MoveToElement();
 312                                 if (Reader.IsEmptyElement) {
 313                                         SetListMembersDefaults (map, ob, isValueList);
 314                                         return;
 315                                 }
 316
 317                                 Reader.ReadStartElement();
 318                         }
 319
 320                         // Reads elements
 321
 322                         bool[] readFlag = new bool[(map.ElementMembers != null) ? map.ElementMembers.Count : 0];
 323
 324                         bool hasAnyReturnMember = (isValueList && _format == SerializationFormat.Encoded && map.ReturnMember != null);
 325
 326                         Reader.MoveToContent();
 327
 328                         int[] indexes = null;
 329                         object[] flatLists = null;
 330                         object[] flatListsChoices = null;
 331                         Fixup fixup = null;
 332                         int ind = -1;
 333                         int maxInd;
 334
 335                         if (readBySoapOrder) {
 336                                 if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
 337                                 else maxInd = -1;
 338                         }
 339                         else
 340                                 maxInd = int.MaxValue;
 341
 342                         if (map.FlatLists != null)
 343                         {
 344                                 indexes = new int[map.FlatLists.Count];
 345                                 flatLists = new object[map.FlatLists.Count];
 346                                 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) {
 347                                         if (IsReadOnly (mem, mem.TypeData, ob, isValueList))
 348                                                 flatLists [mem.FlatArrayIndex] = mem.GetValue (ob);
 349                                         else if (mem.TypeData.Type.IsArray) {
 350                                                 flatLists [mem.FlatArrayIndex] = InitializeList (mem.TypeData);
 351                                         }
 352                                         else {
 353                                                 object list = mem.GetValue (ob);
 354                                                 if (list == null) {
 355                                                         list = InitializeList (mem.TypeData);
 356                                                         SetMemberValue (mem, ob, list, isValueList);
 357                                                 }
 358                                                 flatLists [mem.FlatArrayIndex] = list;
 359                                         }
 360
 361                                         if (mem.ChoiceMember != null) {
 362                                                 if (flatListsChoices == null)
 363                                                         flatListsChoices = new object [map.FlatLists.Count];
 364                                                 flatListsChoices [mem.FlatArrayIndex] = InitializeList (mem.ChoiceTypeData);
 365                                         }
 366                                 }
 367                         }
 368
 369                         if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
 370                         {
 371                                 FixupCallbackInfo info = new FixupCallbackInfo (this, map, isValueList);
 372                                 fixup = new Fixup(ob, new XmlSerializationFixupCallback(info.FixupMembers), map.ElementMembers.Count);
 373                                 AddFixup (fixup);
 374                         }
 375
 376                         XmlTypeMapMember previousMember = null;
 377                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd - 1))
 378                         {
 379                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 380                                 {
 381                                         XmlTypeMapElementInfo info;
 382
 383                                         if (readBySoapOrder) {
 384                                                 info = map.GetElement (Reader.LocalName, Reader.NamespaceURI);
 385                                         }
 386                                         else if (hasAnyReturnMember) {
 387                                                 info = (XmlTypeMapElementInfo) ((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0];
 388                                                 hasAnyReturnMember = false;
 389                                         }
 390                                         else {
 391                                                 if (map.IsOrderDependentMap) {
 392                                                         info = map.GetElement (Reader.LocalName, Reader.NamespaceURI);
 393                                                 }
 394                                                 else
 395                                                         info = map.GetElement (Reader.LocalName, Reader.NamespaceURI, -1);
 396                                         }
 397
 398                                         if (info != null && !readFlag[info.Member.Index] )
 399                                         {
 400                                                 if (info.Member != previousMember)
 401                                                 {
 402                                                         ind++;
 403                                                         previousMember = info.Member;
 404                                                 }
 405
 406                                                 if (readBySoapOrder && info.ExplicitOrder != ind)
 407                                                         throw new InvalidOperationException(string.Format("Element '{0}' has wrong order in sequence (expected - {1}, actual - {2}", Reader.LocalName, info.ExplicitOrder, ind));
 408
 409
 410                                                 if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
 411                                                 {
 412                                                         if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
 413                                                         {
 414                                                                 object list = ReadReferencingElement (out fixup.Ids[info.Member.Index]);
 415                                                                 if (fixup.Ids[info.Member.Index] == null)       // Already read
 416                                                                 {
 417                                                                         if (IsReadOnly (info.Member, info.TypeData, ob, isValueList)) throw CreateReadOnlyCollectionException (info.TypeData.FullTypeName);
 418                                                                         else SetMemberValue (info.Member, ob, list, isValueList);
 419                                                                 }
 420                                                                 else if (!info.MappedType.TypeData.Type.IsArray)
 421                                                                 {
 422                                                                         if (IsReadOnly (info.Member, info.TypeData, ob, isValueList))
 423                                                                                 list = GetMemberValue (info.Member, ob, isValueList);
 424                                                                         else {
 425                                                                                 list = CreateList (info.MappedType.TypeData.Type);
 426                                                                                 SetMemberValue (info.Member, ob, list, isValueList);
 427                                                                         }
 428                                                                         AddFixup (new CollectionFixup (list, new XmlSerializationCollectionFixupCallback (FillList), fixup.Ids[info.Member.Index]));
 429                                                                         fixup.Ids[info.Member.Index] = null;    // The member already has the value, no further fix needed.
 430                                                                 }
 431                                                         }
 432                                                         else
 433                                                         {
 434                                                                 if (IsReadOnly (info.Member, info.TypeData, ob, isValueList)) {
 435                                                                         ReadListElement (info.MappedType, info.IsNullable, GetMemberValue (info.Member, ob, isValueList), false);
 436                                                                 } else if (info.MappedType.TypeData.Type.IsArray) {
 437                                                                         object list = ReadListElement (info.MappedType, info.IsNullable, null, true);
 438                                                                         if (list != null || info.IsNullable)
 439                                                                                 SetMemberValue (info.Member, ob, list, isValueList);
 440                                                                 } else {
 441                                                                         // If the member already has a list, reuse that list. No need to create a new one.
 442                                                                         object list = GetMemberValue (info.Member, ob, isValueList);
 443                                                                         if (list == null) {
 444                                                                                 list = CreateList (info.MappedType.TypeData.Type);
 445                                                                                 SetMemberValue (info.Member, ob, list, isValueList);
 446                                                                         }
 447                                                                         ReadListElement (info.MappedType, info.IsNullable, list, true);
 448                                                                 }
 449                                                         }
 450                                                         readFlag[info.Member.Index] = true;
 451                                                 }
 452                                                 else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
 453                                                 {
 454                                                         XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
 455                                                         AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement (info), !IsReadOnly (info.Member, info.TypeData, ob, isValueList));
 456                                                         if (mem.ChoiceMember != null) {
 457                                                                 AddListValue (mem.ChoiceTypeData, ref flatListsChoices [mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]-1, info.ChoiceValue, true);
 458                                                         }
 459                                                 }
 460                                                 else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
 461                                                 {
 462                                                         XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
 463                                                         if (mem.TypeData.IsListType) AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
 464                                                         else SetMemberValue (mem, ob, ReadXmlNode (mem.TypeData, false), isValueList);
 465                                                 }
 466                                                 else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
 467                                                 {
 468                                                         object val;
 469                                                         readFlag[info.Member.Index] = true;
 470                                                         if (_format == SerializationFormat.Encoded)
 471                                                         {
 472                                                                 if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
 473                                                                         val = ReadReferencingElement (out fixup.Ids[info.Member.Index]);
 474                                                                 else
 475                                                                         val = ReadReferencingElement (info.Member.TypeData.XmlType, System.Xml.Schema.XmlSchema.Namespace, out fixup.Ids[info.Member.Index]);
 476
 477                                                                 if (info.MultiReferenceType) {
 478                                                                         if (fixup.Ids[info.Member.Index] == null)       // already read
 479                                                                                 SetMemberValue (info.Member, ob, val, isValueList);
 480                                                                 }
 481                                                                 else if (val != null)
 482                                                                         SetMemberValue (info.Member, ob, val, isValueList);
 483                                                         }
 484                                                         else {
 485                                                                 SetMemberValue (info.Member, ob, ReadObjectElement (info), isValueList);
 486                                                                 if (info.ChoiceValue != null) {
 487                                                                         XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement) info.Member;
 488                                                                         imem.SetChoice (ob, info.ChoiceValue);
 489                                                                 }
 490                                                         }
 491                                                 }
 492                                                 else
 493                                                         throw new InvalidOperationException ("Unknown member type");
 494                                         }
 495                                         else if (map.DefaultAnyElementMember != null)
 496                                         {
 497                                                 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
 498                                                 if (mem.TypeData.IsListType) AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
 499                                                 else SetMemberValue (mem, ob, ReadXmlNode (mem.TypeData, false), isValueList);
 500                                         }
 501                                         else
 502                                                 ProcessUnknownElement(ob);
 503                                 }
 504                                 else if ((Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA) && map.XmlTextCollector != null)
 505                                 {
 506                                         if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
 507                                         {
 508                                                 XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
 509                                                 XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
 510                                                 TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
 511
 512                                                 object val = (itype.Type == typeof (string)) ? (object) Reader.ReadString() : (object) ReadXmlNode (itype, false);
 513                                                 AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, val, true);
 514                                         }
 515                                         else
 516                                         {
 517                                                 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
 518                                                 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
 519                                                 if (info.TypeData.Type == typeof (string))
 520                                                         SetMemberValue (mem, ob, ReadString ((string) GetMemberValue (mem, ob, isValueList)), isValueList);
 521                                                 else
 522                                                         SetMemberValue (mem, ob, GetValueFromXmlString (Reader.ReadString(), info.TypeData, info.MappedType), isValueList);
 523                                         }
 524                                 }
 525 #if !MOONLIGHT
 526                                 else
 527                                         UnknownNode(ob);
 528 #endif
 529                                 Reader.MoveToContent();
 530                         }
 531
 532                         if (flatLists != null)
 533                         {
 534                                 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
 535                                 {
 536                                         Object list = flatLists[mem.FlatArrayIndex];
 537                                         if (mem.TypeData.Type.IsArray)
 538                                                 list = ShrinkArray ((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true);
 539                                         if (!IsReadOnly (mem, mem.TypeData, ob, isValueList) && mem.TypeData.Type.IsArray)
 540                                                 SetMemberValue (mem, ob, list, isValueList);
 541                                 }
 542                         }
 543
 544                         if (flatListsChoices != null)
 545                         {
 546                                 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
 547                                 {
 548                                         Object list = flatListsChoices[mem.FlatArrayIndex];
 549                                         if (list == null) continue;
 550                                         list = ShrinkArray ((Array)list, indexes[mem.FlatArrayIndex], mem.ChoiceTypeData.Type.GetElementType(), true);
 551                                         XmlTypeMapMember.SetValue (ob, mem.ChoiceMember, list);
 552                                 }
 553                         }
 554                         SetListMembersDefaults (map, ob, isValueList);
 555                 }
 556
 557                 void SetListMembersDefaults (ClassMap map, object ob, bool isValueList)
 558                 {
 559                         if (map.ListMembers != null)
 560                         {
 561                                 ArrayList members = map.ListMembers;
 562                                 for (int n=0; n<members.Count; n++) {
 563                                         XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
 564                                         if (IsReadOnly (mem, mem.TypeData, ob, isValueList))
 565                                                 continue;
 566                                         if (GetMemberValue (mem, ob, isValueList) == null)
 567                                                 SetMemberValue (mem, ob, InitializeList (mem.TypeData), isValueList);
 568                                 }
 569                         }
 570                 }
 571
 572                 internal void FixupMembers (ClassMap map, object obfixup, bool isValueList)
 573                 {
 574                         Fixup fixup = (Fixup)obfixup;
 575                         ICollection members = map.ElementMembers;
 576                         string[] ids = fixup.Ids;
 577                         foreach (XmlTypeMapMember member in members)
 578                         {
 579                                 if (ids[member.Index] != null)
 580                                         SetMemberValue (member, fixup.Source, GetTarget(ids[member.Index]), isValueList);
 581                         }
 582                 }
 583
 584                 protected virtual void ProcessUnknownAttribute (object target)
 585                 {
 586                         UnknownNode (target);
 587                 }
 588
 589                 protected virtual void ProcessUnknownElement (object target)
 590                 {
 591                         UnknownNode (target);
 592                 }
 593
 594                 bool IsReadOnly (XmlTypeMapMember member, TypeData memType, object ob, bool isValueList)
 595                 {
 596                         if (isValueList) return !memType.HasPublicConstructor;
 597                         else return member.IsReadOnly (ob.GetType()) || !memType.HasPublicConstructor;
 598                 }
 599
 600                 void SetMemberValue (XmlTypeMapMember member, object ob, object value, bool isValueList)
 601                 {
 602                         if (isValueList)
 603                                 ((object[])ob)[member.GlobalIndex] = value;
 604                         else
 605                                 member.SetValue (ob, value);
 606                         if (member.IsOptionalValueType)
 607                                 member.SetValueSpecified (ob, true);
 608                 }
 609
 610                 void SetMemberValueFromAttr (XmlTypeMapMember member, object ob, object value, bool isValueList)
 611                 {
 612                         // Enumeration values specified in custom attributes are stored as integer
 613                         // values if the custom attribute property is of type object. So, it is
 614                         // necessary to convert to the enum type before asigning the value to the field.
 615
 616                         if (member.TypeData.Type.IsEnum)
 617                                 value = Enum.ToObject (member.TypeData.Type, value);
 618                         SetMemberValue (member, ob, value, isValueList);
 619                 }
 620
 621                 object GetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
 622                 {
 623                         if (isValueList) return ((object[])ob)[member.GlobalIndex];
 624                         else return member.GetValue (ob);
 625                 }
 626
 627                 object ReadObjectElement (XmlTypeMapElementInfo elem)
 628                 {
 629                         switch (elem.TypeData.SchemaType)
 630                         {
 631                                 case SchemaTypes.XmlNode:
 632                                         return ReadXmlNode (elem.TypeData, true);
 633
 634                                 case SchemaTypes.Primitive:
 635                                 case SchemaTypes.Enum:
 636                                         return ReadPrimitiveValue (elem);
 637
 638                                 case SchemaTypes.Array:
 639                                         return ReadListElement (elem.MappedType, elem.IsNullable, null, true);
 640
 641                                 case SchemaTypes.Class:
 642                                         return ReadObject (elem.MappedType, elem.IsNullable, true);
 643
 644                                 case SchemaTypes.XmlSerializable:
 645                                         object ob = CreateInstance (elem.TypeData.Type, true);
 646                                         return ReadSerializable ((IXmlSerializable)ob);
 647
 648                                 default:
 649                                         throw new NotSupportedException ("Invalid value type");
 650                         }
 651                 }
 652
 653                 object ReadPrimitiveValue (XmlTypeMapElementInfo elem)
 654                 {
 655                         if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
 656                                 if (elem.IsNullable) return ReadNullableQualifiedName ();
 657                                 else return ReadElementQualifiedName ();
 658                         }
 659                         else if (elem.IsNullable)
 660                                 return GetValueFromXmlString (ReadNullableString (), elem.TypeData, elem.MappedType);
 661                         else
 662                                 return GetValueFromXmlString (Reader.ReadElementString (), elem.TypeData, elem.MappedType);
 663                 }
 664
 665                 object GetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
 666                 {
 667                         if (typeData.SchemaType == SchemaTypes.Array)
 668                                 return ReadListString (typeMap, value);
 669                         else if (typeData.SchemaType == SchemaTypes.Enum)
 670                                 return GetEnumValue (typeMap, value);
 671                         else if (typeData.Type == typeof (XmlQualifiedName))
 672                                 return ToXmlQualifiedName (value);
 673                         else
 674                                 return XmlCustomFormatter.FromXmlString (typeData, value);
 675                 }
 676
 677                 object ReadListElement (XmlTypeMapping typeMap, bool isNullable, object list, bool canCreateInstance)
 678                 {
 679                         Type listType = typeMap.TypeData.Type;
 680                         ListMap listMap = (ListMap)typeMap.ObjectMap;
 681
 682                         if (listType.IsArray && ReadNull()) return null;
 683
 684                         if (list == null) {
 685                                 if (canCreateInstance && typeMap.TypeData.HasPublicConstructor) list = CreateList (listType);
 686                                 else throw CreateReadOnlyCollectionException (typeMap.TypeFullName);
 687                         }
 688
 689                         if (Reader.IsEmptyElement) {
 690                                 Reader.Skip();
 691                                 if (listType.IsArray)
 692                                         list = ShrinkArray ((Array)list, 0, listType.GetElementType(), false);
 693                                 return list;
 694                         }
 695
 696                         int index = 0;
 697                         Reader.ReadStartElement();
 698                         Reader.MoveToContent();
 699
 700                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
 701                         {
 702                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
 703                                 {
 704                                         XmlTypeMapElementInfo elemInfo = listMap.FindElement (Reader.LocalName, Reader.NamespaceURI);
 705                                         if (elemInfo != null)
 706                                                 AddListValue (typeMap.TypeData, ref list, index++, ReadObjectElement (elemInfo), false);
 707                                         else
 708                                                 UnknownNode(null);
 709                                 }
 710                                 else
 711                                         UnknownNode(null);
 712
 713                                 Reader.MoveToContent();
 714                         }
 715                         ReadEndElement();
 716
 717                         if (listType.IsArray)
 718                                 list = ShrinkArray ((Array)list, index, listType.GetElementType(), false);
 719
 720                         return list;
 721                 }
 722
 723                 object ReadListString (XmlTypeMapping typeMap, string values)
 724                 {
 725                         Type listType = typeMap.TypeData.Type;
 726                         ListMap listMap = (ListMap)typeMap.ObjectMap;
 727                         values = values.Trim ();
 728
 729                         if (values == string.Empty)
 730                         {
 731                                 return Array.CreateInstance (listType.GetElementType(), 0);
 732                         }
 733
 734                         string[] valueArray = values.Split (' ');
 735                         Array list = Array.CreateInstance (listType.GetElementType(), valueArray.Length);
 736
 737                         XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
 738
 739                         for (int index = 0; index < valueArray.Length; index++)
 740                                 list.SetValue (GetValueFromXmlString (valueArray[index], info.TypeData, info.MappedType), index);
 741
 742                         return list;
 743                 }
 744
 745                 void AddListValue (TypeData listType, ref object list, int index, object value, bool canCreateInstance)
 746                 {
 747                         Type type = listType.Type;
 748                         if (type.IsArray)
 749                         {
 750                                 list = EnsureArrayIndex ((Array)list, index, type.GetElementType());
 751                                 ((Array)list).SetValue (value, index);
 752                         }
 753                         else    // Must be IEnumerable
 754                         {
 755                                 if (list == null) {
 756                                         if (canCreateInstance) list = CreateInstance (type, true);
 757                                         else throw CreateReadOnlyCollectionException (type.FullName);
 758                                 }
 759
 760                                 MethodInfo mi = type.GetMethod ("Add", new Type[] {listType.ListItemType} );
 761                                 mi.Invoke (list, new object[] { value });
 762                         }
 763                 }
 764
 765                 static object CreateInstance (Type type, bool nonPublic)
 766                 {
 767 #if MOONLIGHT
 768                         return Activator.CreateInstance (type); // always false
 769 #else
 770                         return Activator.CreateInstance (type, nonPublic);
 771 #endif
 772                 }
 773
 774                 object CreateInstance (Type type)
 775                 {
 776                         return Activator.CreateInstance (type, empty_array);
 777                 }
 778
 779                 object CreateList (Type listType)
 780                 {
 781                         if (listType.IsArray)
 782                                 return EnsureArrayIndex (null, 0, listType.GetElementType());
 783                         else
 784                                 return CreateInstance (listType, true);
 785                 }
 786
 787                 object InitializeList (TypeData listType)
 788                 {
 789                         if (listType.Type.IsArray)
 790                                 return null;
 791                         else
 792                                 return CreateInstance (listType.Type, true);
 793                 }
 794
 795                 void FillList (object list, object items)
 796                 {
 797                         CopyEnumerableList (items, list);
 798                 }
 799
 800                 void CopyEnumerableList (object source, object dest)
 801                 {
 802                         if (dest == null) throw CreateReadOnlyCollectionException (source.GetType().FullName);
 803
 804                         object[] param = new object[1];
 805                         MethodInfo mi = dest.GetType().GetMethod ("Add");
 806                         foreach (object ob in (IEnumerable)source)
 807                         {
 808                                 param[0] = ob;
 809                                 mi.Invoke (dest, param);
 810                         }
 811                 }
 812
 813                 object ReadXmlNodeElement (XmlTypeMapping typeMap, bool isNullable)
 814                 {
 815                         return ReadXmlNode (typeMap.TypeData, false);
 816                 }
 817
 818                 object ReadXmlNode (TypeData type, bool wrapped)
 819                 {
 820 #if MOONLIGHT
 821                         throw new NotSupportedException ();
 822 #else
 823                         if (type.Type == typeof (XmlDocument))
 824                                 return ReadXmlDocument (wrapped);
 825                         else
 826                                 return ReadXmlNode (wrapped);
 827 #endif
 828                 }
 829
 830                 object ReadPrimitiveElement (XmlTypeMapping typeMap, bool isNullable)
 831                 {
 832                         XmlQualifiedName t = GetXsiType();
 833                         if (t == null) t = new XmlQualifiedName (typeMap.XmlType, typeMap.Namespace);
 834                         return ReadTypedPrimitive (t);
 835                 }
 836
 837                 object ReadEnumElement (XmlTypeMapping typeMap, bool isNullable)
 838                 {
 839                         Reader.ReadStartElement ();
 840                         object o = GetEnumValue (typeMap, Reader.ReadString());
 841                         ReadEndElement ();
 842                         return o;
 843                 }
 844
 845                 object GetEnumValue (XmlTypeMapping typeMap, string val)
 846                 {
 847                         if (val == null)
 848                                 return null;
 849                         EnumMap map = (EnumMap) typeMap.ObjectMap;
 850                         string ev = map.GetEnumName (typeMap.TypeFullName, val);
 851                         if (ev == null) throw CreateUnknownConstantException (val, typeMap.TypeData.Type);
 852                         return Enum.Parse (typeMap.TypeData.Type, ev, false);
 853                 }
 854
 855                 object ReadXmlSerializableElement (XmlTypeMapping typeMap, bool isNullable)
 856                 {
 857                         Reader.MoveToContent ();
 858                         if (Reader.NodeType == XmlNodeType.Element)
 859                         {
 860                                 if (Reader.LocalName == typeMap.ElementName && Reader.NamespaceURI == typeMap.Namespace)
 861                                 {
 862                                         object ob = CreateInstance (typeMap.TypeData.Type, true);
 863                                         return ReadSerializable ((IXmlSerializable)ob);
 864                                 }
 865                                 else
 866                                         throw CreateUnknownNodeException ();
 867                         }
 868                         else
 869                         {
 870                                 UnknownNode (null);
 871                                 return null;
 872                         }
 873                 }
 874
 875                 class FixupCallbackInfo
 876                 {
 877                         XmlSerializationReaderInterpreter _sri;
 878                         ClassMap _map;
 879                         bool _isValueList;
 880
 881                         public FixupCallbackInfo (XmlSerializationReaderInterpreter sri, ClassMap map, bool isValueList)
 882                         {
 883                                 _sri = sri;
 884                                 _map = map;
 885                                 _isValueList = isValueList;
 886                         }
 887
 888                         public void FixupMembers (object fixup)
 889                         {
 890                                 _sri.FixupMembers (_map, fixup, _isValueList);
 891                         }
 892                 }
 893
 894                 class ReaderCallbackInfo
 895                 {
 896                         XmlSerializationReaderInterpreter _sri;
 897                         XmlTypeMapping _typeMap;
 898
 899                         public ReaderCallbackInfo (XmlSerializationReaderInterpreter sri, XmlTypeMapping typeMap)
 900                         {
 901                                 _sri = sri;
 902                                 _typeMap = typeMap;
 903                         }
 904
 905                         internal object ReadObject ()
 906                         {
 907                                 return _sri.ReadObject (_typeMap, true, true);
 908                         }
 909                 }
 910         }
 911 }