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