?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Jb Evain <jbevain@novell.com>
[mcs.git] / class / System.XML / System.Xml.Serialization / XmlSerializationReaderInterpreter.cs
blob329405fb1445b1c7c402cfcc8264c377a5529ef8
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 (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 = Activator.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 readByOrder)
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 = 0;
321 int maxInd;
322
323 if (readByOrder) {
324 if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
325 else maxInd = 0;
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 while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd))
365 {
366 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
367 {
368 XmlTypeMapElementInfo info;
369
370 if (readByOrder) {
371 info = map.GetElement (ind++);
372 }
373 else if (hasAnyReturnMember) {
374 info = (XmlTypeMapElementInfo) ((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0];
375 hasAnyReturnMember = false;
376 }
377 else
378 info = map.GetElement (Reader.LocalName, Reader.NamespaceURI);
379
380 if (info != null && !readFlag[info.Member.Index] )
381 {
382 if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
383 {
384 if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
385 {
386 object list = ReadReferencingElement (out fixup.Ids[info.Member.Index]);
387 if (fixup.Ids[info.Member.Index] == null) // Already read
388 {
389 if (IsReadOnly (info.Member, info.TypeData, ob, isValueList)) throw CreateReadOnlyCollectionException (info.TypeData.FullTypeName);
390 else SetMemberValue (info.Member, ob, list, isValueList);
391 }
392 else if (!info.MappedType.TypeData.Type.IsArray)
393 {
394 if (IsReadOnly (info.Member, info.TypeData, ob, isValueList))
395 list = GetMemberValue (info.Member, ob, isValueList);
396 else {
397 list = CreateList (info.MappedType.TypeData.Type);
398 SetMemberValue (info.Member, ob, list, isValueList);
399 }
400 AddFixup (new CollectionFixup (list, new XmlSerializationCollectionFixupCallback (FillList), fixup.Ids[info.Member.Index]));
401 fixup.Ids[info.Member.Index] = null; // The member already has the value, no further fix needed.
402 }
403 }
404 else
405 {
406 if (IsReadOnly (info.Member, info.TypeData, ob, isValueList)) {
407 ReadListElement (info.MappedType, info.IsNullable, GetMemberValue (info.Member, ob, isValueList), false);
408 } else if (info.MappedType.TypeData.Type.IsArray) {
409 object list = ReadListElement (info.MappedType, info.IsNullable, null, true);
410 if (list != null || info.IsNullable)
411 SetMemberValue (info.Member, ob, list, isValueList);
412 } else {
413 // If the member already has a list, reuse that list. No need to create a new one.
414 object list = GetMemberValue (info.Member, ob, isValueList);
415 if (list == null) {
416 list = CreateList (info.MappedType.TypeData.Type);
417 SetMemberValue (info.Member, ob, list, isValueList);
418 }
419 ReadListElement (info.MappedType, info.IsNullable, list, true);
420 }
421 }
422 readFlag[info.Member.Index] = true;
423 }
424 else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
425 {
426 XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
427 AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadObjectElement (info), !IsReadOnly (info.Member, info.TypeData, ob, isValueList));
428 if (mem.ChoiceMember != null) {
429 AddListValue (mem.ChoiceTypeData, ref flatListsChoices [mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]-1, info.ChoiceValue, true);
430 }
431 }
432 else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
433 {
434 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
435 if (mem.TypeData.IsListType) AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
436 else SetMemberValue (mem, ob, ReadXmlNode (mem.TypeData, false), isValueList);
437 }
438 else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
439 {
440 object val;
441 readFlag[info.Member.Index] = true;
442 if (_format == SerializationFormat.Encoded)
443 {
444 if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
445 val = ReadReferencingElement (out fixup.Ids[info.Member.Index]);
446 else
447 val = ReadReferencingElement (info.Member.TypeData.XmlType, System.Xml.Schema.XmlSchema.Namespace, out fixup.Ids[info.Member.Index]);
448
449 if (info.MultiReferenceType) {
450 if (fixup.Ids[info.Member.Index] == null) // already read
451 SetMemberValue (info.Member, ob, val, isValueList);
452 }
453 else if (val != null)
454 SetMemberValue (info.Member, ob, val, isValueList);
455 }
456 else {
457 SetMemberValue (info.Member, ob, ReadObjectElement (info), isValueList);
458 if (info.ChoiceValue != null) {
459 XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement) info.Member;
460 imem.SetChoice (ob, info.ChoiceValue);
461 }
462 }
463 }
464 else
465 throw new InvalidOperationException ("Unknown member type");
466 }
467 else if (map.DefaultAnyElementMember != null)
468 {
469 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
470 if (mem.TypeData.IsListType) AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, ReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
471 else SetMemberValue (mem, ob, ReadXmlNode (mem.TypeData, false), isValueList);
472 }
473 else
474 ProcessUnknownElement(ob);
475 }
476 else if ((Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA) && map.XmlTextCollector != null)
477 {
478 if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
479 {
480 XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
481 XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
482 TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
483
484 object val = (itype.Type == typeof (string)) ? (object) Reader.ReadString() : (object) ReadXmlNode (itype, false);
485 AddListValue (mem.TypeData, ref flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex]++, val, true);
486 }
487 else
488 {
489 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
490 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
491 if (info.TypeData.Type == typeof (string))
492 SetMemberValue (mem, ob, ReadString ((string) GetMemberValue (mem, ob, isValueList)), isValueList);
493 else
494 SetMemberValue (mem, ob, GetValueFromXmlString (Reader.ReadString(), info.TypeData, info.MappedType), isValueList);
495 }
496 }
497 else
498 UnknownNode(ob);
499
500 Reader.MoveToContent();
501 }
502
503 if (flatLists != null)
504 {
505 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
506 {
507 Object list = flatLists[mem.FlatArrayIndex];
508 if (mem.TypeData.Type.IsArray)
509 list = ShrinkArray ((Array)list, indexes[mem.FlatArrayIndex], mem.TypeData.Type.GetElementType(), true);
510 if (!IsReadOnly (mem, mem.TypeData, ob, isValueList) && mem.TypeData.Type.IsArray)
511 SetMemberValue (mem, ob, list, isValueList);
512 }
513 }
514
515 if (flatListsChoices != null)
516 {
517 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
518 {
519 Object list = flatListsChoices[mem.FlatArrayIndex];
520 if (list == null) continue;
521 list = ShrinkArray ((Array)list, indexes[mem.FlatArrayIndex], mem.ChoiceTypeData.Type.GetElementType(), true);
522 XmlTypeMapMember.SetValue (ob, mem.ChoiceMember, list);
523 }
524 }
525 SetListMembersDefaults (map, ob, isValueList);
526 }
527
528 void SetListMembersDefaults (ClassMap map, object ob, bool isValueList)
529 {
530 if (map.ListMembers != null)
531 {
532 ArrayList members = map.ListMembers;
533 for (int n=0; n<members.Count; n++) {
534 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
535 if (IsReadOnly (mem, mem.TypeData, ob, isValueList))
536 continue;
537 if (GetMemberValue (mem, ob, isValueList) == null)
538 SetMemberValue (mem, ob, InitializeList (mem.TypeData), isValueList);
539 }
540 }
541 }
542
543 internal void FixupMembers (ClassMap map, object obfixup, bool isValueList)
544 {
545 Fixup fixup = (Fixup)obfixup;
546 ICollection members = map.ElementMembers;
547 string[] ids = fixup.Ids;
548 foreach (XmlTypeMapMember member in members)
549 {
550 if (ids[member.Index] != null)
551 SetMemberValue (member, fixup.Source, GetTarget(ids[member.Index]), isValueList);
552 }
553 }
554
555 protected virtual void ProcessUnknownAttribute (object target)
556 {
557 UnknownNode (target);
558 }
559
560 protected virtual void ProcessUnknownElement (object target)
561 {
562 UnknownNode (target);
563 }
564
565 bool IsReadOnly (XmlTypeMapMember member, TypeData memType, object ob, bool isValueList)
566 {
567 if (isValueList) return !memType.HasPublicConstructor;
568 else return member.IsReadOnly (ob.GetType()) || !memType.HasPublicConstructor;
569 }
570
571 void SetMemberValue (XmlTypeMapMember member, object ob, object value, bool isValueList)
572 {
573 if (isValueList) ((object[])ob)[member.GlobalIndex] = value;
574 else {
575 member.SetValue (ob, value);
576 if (member.IsOptionalValueType)
577 member.SetValueSpecified (ob, true);
578 }
579 }
580
581 void SetMemberValueFromAttr (XmlTypeMapMember member, object ob, object value, bool isValueList)
582 {
583 // Enumeration values specified in custom attributes are stored as integer
584 // values if the custom attribute property is of type object. So, it is
585 // necessary to convert to the enum type before asigning the value to the field.
586
587 if (member.TypeData.Type.IsEnum)
588 value = Enum.ToObject (member.TypeData.Type, value);
589 SetMemberValue (member, ob, value, isValueList);
590 }
591
592 object GetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
593 {
594 if (isValueList) return ((object[])ob)[member.GlobalIndex];
595 else return member.GetValue (ob);
596 }
597
598 object ReadObjectElement (XmlTypeMapElementInfo elem)
599 {
600 switch (elem.TypeData.SchemaType)
601 {
602 case SchemaTypes.XmlNode:
603 return ReadXmlNode (elem.TypeData, true);
604
605 case SchemaTypes.Primitive:
606 case SchemaTypes.Enum:
607 return ReadPrimitiveValue (elem);
608
609 case SchemaTypes.Array:
610 return ReadListElement (elem.MappedType, elem.IsNullable, null, true);
611
612 case SchemaTypes.Class:
613 return ReadObject (elem.MappedType, elem.IsNullable, true);
614
615 case SchemaTypes.XmlSerializable:
616 object ob = Activator.CreateInstance (elem.TypeData.Type, true);
617 return ReadSerializable ((IXmlSerializable)ob);
618
619 default:
620 throw new NotSupportedException ("Invalid value type");
621 }
622 }
623
624 object ReadPrimitiveValue (XmlTypeMapElementInfo elem)
625 {
626 if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
627 if (elem.IsNullable) return ReadNullableQualifiedName ();
628 else return ReadElementQualifiedName ();
629 }
630 else if (elem.IsNullable)
631 return GetValueFromXmlString (ReadNullableString (), elem.TypeData, elem.MappedType);
632 else
633 return GetValueFromXmlString (Reader.ReadElementString (), elem.TypeData, elem.MappedType);
634 }
635
636 object GetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
637 {
638 if (typeData.SchemaType == SchemaTypes.Array)
639 return ReadListString (typeMap, value);
640 else if (typeData.SchemaType == SchemaTypes.Enum)
641 return GetEnumValue (typeMap, value);
642 else if (typeData.Type == typeof (XmlQualifiedName))
643 return ToXmlQualifiedName (value);
644 else
645 return XmlCustomFormatter.FromXmlString (typeData, value);
646 }
647
648 object ReadListElement (XmlTypeMapping typeMap, bool isNullable, object list, bool canCreateInstance)
649 {
650 Type listType = typeMap.TypeData.Type;
651 ListMap listMap = (ListMap)typeMap.ObjectMap;
652
653 if (listType.IsArray && ReadNull()) return null;
654
655 if (list == null) {
656 if (canCreateInstance && typeMap.TypeData.HasPublicConstructor) list = CreateList (listType);
657 else throw CreateReadOnlyCollectionException (typeMap.TypeFullName);
658 }
659
660 if (Reader.IsEmptyElement) {
661 Reader.Skip();
662 if (listType.IsArray)
663 list = ShrinkArray ((Array)list, 0, listType.GetElementType(), false);
664 return list;
665 }
666
667 int index = 0;
668 Reader.ReadStartElement();
669 Reader.MoveToContent();
670
671 while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
672 {
673 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
674 {
675 XmlTypeMapElementInfo elemInfo = listMap.FindElement (Reader.LocalName, Reader.NamespaceURI);
676 if (elemInfo != null)
677 AddListValue (typeMap.TypeData, ref list, index++, ReadObjectElement (elemInfo), false);
678 else
679 UnknownNode(null);
680 }
681 else
682 UnknownNode(null);
683
684 Reader.MoveToContent();
685 }
686 ReadEndElement();
687
688 if (listType.IsArray)
689 list = ShrinkArray ((Array)list, index, listType.GetElementType(), false);
690
691 return list;
692 }
693
694 object ReadListString (XmlTypeMapping typeMap, string values)
695 {
696 Type listType = typeMap.TypeData.Type;
697 ListMap listMap = (ListMap)typeMap.ObjectMap;
698 values = values.Trim ();
699
700 if (values == string.Empty)
701 {
702 return Array.CreateInstance (listType.GetElementType(), 0);
703 }
704
705 string[] valueArray = values.Split (' ');
706 Array list = Array.CreateInstance (listType.GetElementType(), valueArray.Length);
707
708 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
709
710 for (int index = 0; index < valueArray.Length; index++)
711 list.SetValue (GetValueFromXmlString (valueArray[index], info.TypeData, info.MappedType), index);
712
713 return list;
714 }
715
716 void AddListValue (TypeData listType, ref object list, int index, object value, bool canCreateInstance)
717 {
718 Type type = listType.Type;
719 if (type.IsArray)
720 {
721 list = EnsureArrayIndex ((Array)list, index, type.GetElementType());
722 ((Array)list).SetValue (value, index);
723 }
724 else // Must be IEnumerable
725 {
726 if (list == null) {
727 if (canCreateInstance) list = Activator.CreateInstance (type, true);
728 else throw CreateReadOnlyCollectionException (type.FullName);
729 }
730
731 MethodInfo mi = type.GetMethod ("Add", new Type[] {listType.ListItemType} );
732 mi.Invoke (list, new object[] { value });
733 }
734 }
735
736 object CreateInstance (Type type)
737 {
738 return Activator.CreateInstance (type, empty_array);
739 }
740
741 object CreateList (Type listType)
742 {
743 if (listType.IsArray)
744 return EnsureArrayIndex (null, 0, listType.GetElementType());
745 else
746 return Activator.CreateInstance (listType, true);
747 }
748
749 object InitializeList (TypeData listType)
750 {
751 if (listType.Type.IsArray)
752 return null;
753 else
754 return Activator.CreateInstance (listType.Type, true);
755 }
756
757 void FillList (object list, object items)
758 {
759 CopyEnumerableList (items, list);
760 }
761
762 void CopyEnumerableList (object source, object dest)
763 {
764 if (dest == null) throw CreateReadOnlyCollectionException (source.GetType().FullName);
765
766 object[] param = new object[1];
767 MethodInfo mi = dest.GetType().GetMethod ("Add");
768 foreach (object ob in (IEnumerable)source)
769 {
770 param[0] = ob;
771 mi.Invoke (dest, param);
772 }
773 }
774
775 object ReadXmlNodeElement (XmlTypeMapping typeMap, bool isNullable)
776 {
777 return ReadXmlNode (typeMap.TypeData, false);
778 }
779
780 object ReadXmlNode (TypeData type, bool wrapped)
781 {
782 if (type.Type == typeof (XmlDocument))
783 return ReadXmlDocument (wrapped);
784 else
785 return ReadXmlNode (wrapped);
786 }
787
788 object ReadPrimitiveElement (XmlTypeMapping typeMap, bool isNullable)
789 {
790 XmlQualifiedName t = GetXsiType();
791 if (t == null) t = new XmlQualifiedName (typeMap.XmlType, typeMap.Namespace);
792 return ReadTypedPrimitive (t);
793 }
794
795 object ReadEnumElement (XmlTypeMapping typeMap, bool isNullable)
796 {
797 Reader.ReadStartElement ();
798 object o = GetEnumValue (typeMap, Reader.ReadString());
799 ReadEndElement ();
800 return o;
801 }
802
803 object GetEnumValue (XmlTypeMapping typeMap, string val)
804 {
805 if (val == null)
806 return null;
807 EnumMap map = (EnumMap) typeMap.ObjectMap;
808 string ev = map.GetEnumName (typeMap.TypeFullName, val);
809 if (ev == null) throw CreateUnknownConstantException (val, typeMap.TypeData.Type);
810 return Enum.Parse (typeMap.TypeData.Type, ev);
811 }
812
813 object ReadXmlSerializableElement (XmlTypeMapping typeMap, bool isNullable)
814 {
815 Reader.MoveToContent ();
816 if (Reader.NodeType == XmlNodeType.Element)
817 {
818 if (Reader.LocalName == typeMap.ElementName && Reader.NamespaceURI == typeMap.Namespace)
819 {
820 object ob = Activator.CreateInstance (typeMap.TypeData.Type, true);
821 return ReadSerializable ((IXmlSerializable)ob);
822 }
823 else
824 throw CreateUnknownNodeException ();
825 }
826 else
827 {
828 UnknownNode (null);
829 return null;
830 }
831 }
832
833 class FixupCallbackInfo
834 {
835 XmlSerializationReaderInterpreter _sri;
836 ClassMap _map;
837 bool _isValueList;
838
839 public FixupCallbackInfo (XmlSerializationReaderInterpreter sri, ClassMap map, bool isValueList)
840 {
841 _sri = sri;
842 _map = map;
843 _isValueList = isValueList;
844 }
845
846 public void FixupMembers (object fixup)
847 {
848 _sri.FixupMembers (_map, fixup, _isValueList);
849 }
850 }
851
852 class ReaderCallbackInfo
853 {
854 XmlSerializationReaderInterpreter _sri;
855 XmlTypeMapping _typeMap;
856
857 public ReaderCallbackInfo (XmlSerializationReaderInterpreter sri, XmlTypeMapping typeMap)
858 {
859 _sri = sri;
860 _typeMap = typeMap;
861 }
862
863 internal object ReadObject ()
864 {
865 return _sri.ReadObject (_typeMap, true, true);
866 }
867 }
868 }
869 }
git-svn mirror of mcs