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