?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / class / System.XML / System.Xml.Serialization / SerializationCodeGenerator.cs
blob488901918195bc0830d64ecd7fad290b4a4d4f25
1 //
2 // System.Xml.Serialization.SerializationCodeGenerator.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.IO;
32 using System.Reflection;
33 using System.Xml.Serialization;
34 using System.Collections;
35 using System.Globalization;
36
37 namespace System.Xml.Serialization
38 {
39 internal class SerializationCodeGenerator
40 {
41 XmlMapping _typeMap;
42 SerializationFormat _format;
43 TextWriter _writer;
44 int _tempVarId = 0;
45 int _indent = 0;
46 Hashtable _uniqueNames = new Hashtable();
47 int _methodId = 0;
48 SerializerInfo _config;
49 ArrayList _mapsToGenerate = new ArrayList ();
50 ArrayList _fixupCallbacks;
51 ArrayList _referencedTypes = new ArrayList ();
52 GenerationResult[] _results;
53 GenerationResult _result;
54 XmlMapping[] _xmlMaps;
55
56 CodeIdentifiers classNames = new CodeIdentifiers ();
57
58 public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
59 {
60 }
61
62 public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
63 {
64 _xmlMaps = xmlMaps;
65 _config = config;
66 }
67
68 public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
69 {
70 _xmlMaps = new XmlMapping [] {xmlMap};
71 _config = config;
72 }
73
74 public static void Generate (string configFileName, string outputPath)
75 {
76 SerializationCodeGeneratorConfiguration cnf = null;
77 StreamReader sr = new StreamReader (configFileName);
78 try
79 {
80 XmlReflectionImporter ri = new XmlReflectionImporter ();
81 ri.AllowPrivateTypes = true;
82 XmlSerializer ser = new XmlSerializer (ri.ImportTypeMapping (typeof (SerializationCodeGeneratorConfiguration)));
83 cnf = (SerializationCodeGeneratorConfiguration) ser.Deserialize (sr);
84 }
85 finally
86 {
87 sr.Close ();
88 }
89
90 if (outputPath == null) outputPath = "";
91
92 CodeIdentifiers ids = new CodeIdentifiers ();
93 if (cnf.Serializers != null)
94 {
95 foreach (SerializerInfo info in cnf.Serializers)
96 {
97 Type type;
98 if (info.Assembly != null)
99 {
100 Assembly asm;
101 try {
102 asm = Assembly.Load (info.Assembly);
103 } catch {
104 asm = Assembly.LoadFrom (info.Assembly);
105 }
106 type = asm.GetType (info.ClassName, true);
107 }
108 else
109 type = Type.GetType (info.ClassName);
110
111 if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
112
113 string file = info.OutFileName;
114 if (file == null || file == "") {
115 int i = info.ClassName.LastIndexOf (".");
116 if (i != -1) file = info.ClassName.Substring (i+1);
117 else file = info.ClassName;
118 file = ids.AddUnique (file, type) + "Serializer.cs";
119 }
120 StreamWriter writer = new StreamWriter (Path.Combine (outputPath, file));
121
122 try
123 {
124 XmlTypeMapping map;
125
126 if (info.SerializationFormat == SerializationFormat.Literal) {
127 XmlReflectionImporter ri = new XmlReflectionImporter ();
128 map = ri.ImportTypeMapping (type);
129 }
130 else {
131 SoapReflectionImporter ri = new SoapReflectionImporter ();
132 map = ri.ImportTypeMapping (type);
133 }
134
135 SerializationCodeGenerator gen = new SerializationCodeGenerator (map, info);
136 gen.GenerateSerializers (writer);
137 }
138 finally
139 {
140 writer.Close ();
141 }
142 }
143 }
144 }
145
146 public void GenerateSerializers (TextWriter writer)
147 {
148 _writer = writer;
149 _results = new GenerationResult [_xmlMaps.Length];
150
151 WriteLine ("using System;");
152 WriteLine ("using System.Xml;");
153 WriteLine ("using System.Xml.Schema;");
154 WriteLine ("using System.Xml.Serialization;");
155 WriteLine ("using System.Text;");
156 WriteLine ("using System.Collections;");
157 WriteLine ("using System.Globalization;");
158 if (_config != null && _config.NamespaceImports != null && _config.NamespaceImports.Length > 0) {
159 foreach (string ns in _config.NamespaceImports)
160 WriteLine ("using " + ns + ";");
161 }
162 WriteLine ("");
163
164 string readerClassName = null;
165 string writerClassName = null;
166 string namspace = null;
167
168 if (_config != null)
169 {
170 readerClassName = _config.ReaderClassName;
171 writerClassName = _config.WriterClassName;
172 namspace = _config.Namespace;
173 }
174
175 if (readerClassName == null || readerClassName == "")
176 readerClassName = "GeneratedReader";
177
178 if (writerClassName == null || writerClassName == "")
179 writerClassName = "GeneratedWriter";
180
181 readerClassName = GetUniqueClassName (readerClassName);
182 writerClassName = GetUniqueClassName (writerClassName);
183
184 Hashtable mapsByNamespace = new Hashtable ();
185 Hashtable generatedMaps = new Hashtable ();
186
187 for (int n=0; n<_xmlMaps.Length; n++)
188 {
189 _typeMap = _xmlMaps [n];
190 if (_typeMap == null) continue;
191
192 _result = generatedMaps [_typeMap] as GenerationResult;
193 if (_result != null) {
194 _results[n] = _result;
195 continue;
196 }
197
198 _result = new GenerationResult ();
199 _results[n] = _result;
200
201 generatedMaps [_typeMap] = _result;
202
203 string typeName;
204 if (_typeMap is XmlTypeMapping) typeName = ((XmlTypeMapping)_typeMap).TypeName;
205 else typeName = ((XmlMembersMapping)_typeMap).ElementName;
206
207 _result.ReaderClassName = readerClassName;
208 _result.WriterClassName = writerClassName;
209
210 if (namspace == null || namspace == "")
211 _result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
212 else
213 _result.Namespace = namspace;
214
215 _result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
216 _result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
217
218 _result.Mapping = _typeMap;
219
220 ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
221 if (maps == null) {
222 maps = new ArrayList ();
223 mapsByNamespace [_result.Namespace] = maps;
224 }
225 maps.Add (_result);
226 }
227
228 foreach (DictionaryEntry entry in mapsByNamespace)
229 {
230 ArrayList maps = (ArrayList) entry.Value;
231
232 WriteLine ("namespace " + entry.Key);
233 WriteLineInd ("{");
234
235 GenerateReader (readerClassName, maps);
236 WriteLine ("");
237 GenerateWriter (writerClassName, maps);
238 WriteLine ("");
239
240 #if NET_2_0
241 GenerateContract (maps);
242 #endif
243
244 WriteLineUni ("}");
245 WriteLine ("");
246 }
247 }
248
249 public GenerationResult[] GenerationResults
250 {
251 get { return _results; }
252 }
253
254 public ArrayList ReferencedTypes
255 {
256 get { return _referencedTypes; }
257 }
258
259 void UpdateGeneratedTypes (ArrayList list)
260 {
261 for (int n=0; n<list.Count; n++)
262 {
263 XmlTypeMapping map = list[n] as XmlTypeMapping;
264 if (map != null && !_referencedTypes.Contains (map.TypeData.Type))
265 _referencedTypes.Add (map.TypeData.Type);
266 }
267 }
268
269 #region Writer Generation
270
271 //*******************************************************
272 // Contract generation
273 //
274
275 #if NET_2_0
276 public void GenerateContract (ArrayList generatedMaps)
277 {
278 // Write the base serializer
279
280 if (generatedMaps.Count == 0) return;
281
282 GenerationResult main = (GenerationResult) generatedMaps[0];
283
284 string baseSerializerName = GetUniqueClassName ("BaseXmlSerializer");
285
286 WriteLine ("");
287 WriteLine ("public class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
288 WriteLineInd ("{");
289 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
290 WriteLine ("return new " + main.ReaderClassName + " ();");
291 WriteLineUni ("}");
292 WriteLine ("");
293
294 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {");
295 WriteLine ("return new " + main.WriterClassName + " ();");
296 WriteLineUni ("}");
297 WriteLine ("");
298
299 WriteLineInd ("public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {");
300 WriteLine ("return true;");
301 WriteLineUni ("}");
302
303 WriteLineUni ("}");
304 WriteLine ("");
305
306 // Write a serializer for each imported map
307
308 foreach (GenerationResult res in generatedMaps)
309 {
310 res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
311
312 WriteLine ("public sealed class " + res.SerializerClassName + " : " + baseSerializerName);
313 WriteLineInd ("{");
314 WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
315 WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
316 WriteLineUni ("}");
317 WriteLine ("");
318
319 WriteLineInd ("protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {");
320 WriteLine ("return ((" + res.ReaderClassName + ")reader)." + res.ReadMethodName + "();");
321 WriteLineUni ("}");
322
323 WriteLineUni ("}");
324 WriteLine ("");
325 }
326
327 WriteLine ("public class XmlSerializerContract : System.Xml.Serialization.IXmlSerializerImplementation");
328 WriteLineInd ("{");
329
330 WriteLine ("System.Collections.Hashtable readMethods = null;");
331 WriteLine ("System.Collections.Hashtable writeMethods = null;");
332 WriteLine ("System.Collections.Hashtable typedSerializers = null;");
333 WriteLine ("");
334
335 WriteLineInd ("public System.Xml.Serialization.XmlSerializationReader Reader {");
336 WriteLineInd ("get {");
337 WriteLine ("return new " + main.ReaderClassName + "();");
338 WriteLineUni ("}");
339 WriteLineUni ("}");
340 WriteLine ("");
341
342 WriteLineInd ("public System.Xml.Serialization.XmlSerializationWriter Writer {");
343 WriteLineInd ("get {");
344 WriteLine ("return new " + main.WriterClassName + "();");
345 WriteLineUni ("}");
346 WriteLineUni ("}");
347 WriteLine ("");
348
349 WriteLineInd ("public System.Collections.Hashtable ReadMethods {");
350 WriteLineInd ("get {");
351 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
352 WriteLineInd ("if (readMethods == null) {");
353 WriteLine ("readMethods = new System.Collections.Hashtable ();");
354 foreach (GenerationResult res in generatedMaps)
355 WriteLine ("readMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.ReadMethodName + "\");");
356 WriteLineUni ("}");
357 WriteLine ("return readMethods;");
358 WriteLineUni ("}");
359 WriteLineUni ("}");
360 WriteLineUni ("}");
361 WriteLine ("");
362
363 WriteLineInd ("public System.Collections.Hashtable WriteMethods {");
364 WriteLineInd ("get {");
365 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
366 WriteLineInd ("if (writeMethods == null) {");
367 WriteLine ("writeMethods = new System.Collections.Hashtable ();");
368 foreach (GenerationResult res in generatedMaps)
369 WriteLine ("writeMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.WriteMethodName + "\");");
370 WriteLineUni ("}");
371 WriteLine ("return writeMethods;");
372 WriteLineUni ("}");
373 WriteLineUni ("}");
374 WriteLineUni ("}");
375 WriteLine ("");
376
377 WriteLineInd ("public System.Collections.Hashtable TypedSerializers {");
378 WriteLineInd ("get {");
379 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
380 WriteLineInd ("if (typedSerializers == null) {");
381 WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
382 foreach (GenerationResult res in generatedMaps)
383 WriteLine ("typedSerializers.Add (@\"" + res.Mapping.GetKey () + "\", new " + res.SerializerClassName + "());");
384 WriteLineUni ("}");
385 WriteLine ("return typedSerializers;");
386 WriteLineUni ("}");
387 WriteLineUni ("}");
388 WriteLineUni ("}");
389
390 WriteLineInd ("public bool CanSerialize (System.Type type) {");
391 foreach (GenerationResult res in generatedMaps) {
392 if (res.Mapping is XmlTypeMapping)
393 WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.FullTypeName + ")) return true;");
394 }
395 WriteLine ("return false;");
396 WriteLineUni ("}");
397
398 WriteLineUni ("}");
399 WriteLine ("");
400 }
401 #endif
402
403
404 //*******************************************************
405 // Writer generation
406 //
407
408 public void GenerateWriter (string writerClassName, ArrayList maps)
409 {
410 _mapsToGenerate = new ArrayList ();
411
412 InitHooks ();
413
414 WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
415 WriteLineInd ("{");
416
417 for (int n=0; n<maps.Count; n++)
418 {
419 GenerationResult res = (GenerationResult) maps [n];
420 _typeMap = res.Mapping;
421 _format = _typeMap.Format;
422 _result = res;
423
424 GenerateWriteRoot ();
425 }
426
427 for (int n=0; n<_mapsToGenerate.Count; n++)
428 {
429 XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
430 GenerateWriteObject (map);
431 if (map.TypeData.SchemaType == SchemaTypes.Enum)
432 GenerateGetXmlEnumValue (map);
433 }
434
435 GenerateWriteInitCallbacks ();
436 UpdateGeneratedTypes (_mapsToGenerate);
437
438 WriteLineUni ("}");
439 }
440
441 void GenerateWriteRoot ()
442 {
443 WriteLine ("public void " +_result.WriteMethodName + " (object o)");
444 WriteLineInd ("{");
445 WriteLine ("WriteStartDocument ();");
446
447 if (_typeMap is XmlTypeMapping)
448 {
449 WriteLine (GetRootTypeName () + " ob = (" + GetRootTypeName () + ") o;");
450 XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
451 if (mp.TypeData.SchemaType == SchemaTypes.Class || mp.TypeData.SchemaType == SchemaTypes.Array)
452 WriteLine ("TopLevelElement ();");
453
454 if (_format == SerializationFormat.Literal) {
455 WriteLine (GetWriteObjectName (mp) + " (ob, " + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", true, false, true);");
456 }
457 else {
458 RegisterReferencingMap (mp);
459 WriteLine ("WritePotentiallyReferencingElement (" + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", ob, " + GetTypeOf(mp.TypeData) + ", true, false);");
460 }
461 }
462 else if (_typeMap is XmlMembersMapping) {
463 WriteLine ("object[] pars = (object[]) o;");
464 GenerateWriteMessage ((XmlMembersMapping) _typeMap);
465 }
466 else
467 throw new InvalidOperationException ("Unknown type map");
468
469 if (_format == SerializationFormat.Encoded)
470 WriteLine ("WriteReferencedElements ();");
471
472 WriteLineUni ("}");
473 WriteLine ("");
474 }
475
476 void GenerateWriteMessage (XmlMembersMapping membersMap)
477 {
478 if (membersMap.HasWrapperElement) {
479 WriteLine ("TopLevelElement ();");
480 WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));");
481
482 /* WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)");
483 WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);");
484 Unindent ();
485
486 WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)");
487 WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);");
488 Unindent ();
489 */
490 }
491
492 GenerateWriteObjectElement (membersMap, "pars", true);
493
494 if (membersMap.HasWrapperElement)
495 WriteLine ("WriteEndElement();");
496 }
497
498 void GenerateGetXmlEnumValue (XmlTypeMapping map)
499 {
500 EnumMap emap = (EnumMap) map.ObjectMap;
501
502 WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeFullName + " val)");
503 WriteLineInd ("{");
504
505 WriteLine ("switch (val)");
506 WriteLineInd ("{");
507 foreach (EnumMap.EnumMapMember mem in emap.Members)
508 WriteLine ("case " + map.TypeFullName + "." + mem.EnumName + ": return " + GetLiteral (mem.XmlName) + ";");
509
510 if (emap.IsFlags)
511 {
512 WriteLineInd ("default:");
513 WriteLine ("System.Text.StringBuilder sb = new System.Text.StringBuilder ();");
514 WriteLine ("string[] enumNames = val.ToString().Split (',');");
515 WriteLine ("foreach (string name in enumNames)");
516 WriteLineInd ("{");
517 WriteLine ("switch (name.Trim())");
518 WriteLineInd ("{");
519
520 foreach (EnumMap.EnumMapMember mem in emap.Members)
521 WriteLine ("case " + GetLiteral(mem.EnumName) + ": sb.Append (" + GetLiteral(mem.XmlName) + ").Append (' '); break; ");
522
523 WriteLine ("default: sb.Append (name.Trim()).Append (' '); break; ");
524 WriteLineUni ("}");
525 WriteLineUni ("}");
526 WriteLine ("return sb.ToString ().Trim();");
527 Unindent ();
528 }
529 else
530 WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
531
532 WriteLineUni ("}");
533
534 WriteLineUni ("}");
535 WriteLine ("");
536 }
537
538 void GenerateWriteObject (XmlTypeMapping typeMap)
539 {
540 WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
541 WriteLineInd ("{");
542
543 PushHookContext ();
544
545 SetHookVar ("$TYPE", typeMap.TypeName);
546 SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
547 SetHookVar ("$OBJECT", "ob");
548 SetHookVar ("$ELEMENT", "element");
549 SetHookVar ("$NAMESPACE", "namesp");
550 SetHookVar ("$NULLABLE", "isNullable");
551
552 if (GenerateWriteHook (HookType.type, typeMap.TypeData.Type))
553 {
554 WriteLineUni ("}");
555 WriteLine ("");
556 PopHookContext ();
557 return;
558 }
559
560 if (!typeMap.TypeData.IsValueType)
561 {
562 WriteLine ("if (ob == null)");
563 WriteLineInd ("{");
564 WriteLineInd ("if (isNullable)");
565
566 if (_format == SerializationFormat.Literal)
567 WriteLine ("WriteNullTagLiteral(element, namesp);");
568 else
569 WriteLine ("WriteNullTagEncoded (element, namesp);");
570
571 WriteLineUni ("return;");
572 WriteLineUni ("}");
573 WriteLine ("");
574 }
575
576 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
577 {
578 if (_format == SerializationFormat.Literal)
579 WriteLine ("WriteElementLiteral (ob, \"\", \"\", true, false);");
580 else
581 WriteLine ("WriteElementEncoded (ob, \"\", \"\", true, false);");
582
583 GenerateEndHook ();
584 WriteLineUni ("}");
585 WriteLine ("");
586 PopHookContext ();
587 return;
588 }
589
590 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlSerializable)
591 {
592 WriteLine ("WriteSerializable (ob, element, namesp, isNullable);");
593
594 GenerateEndHook ();
595 WriteLineUni ("}");
596 WriteLine ("");
597 PopHookContext ();
598 return;
599 }
600
601 ArrayList types = typeMap.DerivedTypes;
602
603 WriteLine ("System.Type type = ob.GetType ();");
604 WriteLine ("if (type == typeof(" + typeMap.TypeFullName + "))");
605 WriteLine ("\t;");
606
607 for (int n=0; n<types.Count; n++)
608 {
609 XmlTypeMapping map = (XmlTypeMapping)types[n];
610
611 WriteLineInd ("else if (type == typeof(" + map.TypeFullName + ")) { ");
612 WriteLine (GetWriteObjectName (map) + "((" + map.TypeFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
613 WriteLine ("return;");
614 WriteLineUni ("}");
615 }
616
617 if (typeMap.TypeData.Type == typeof (object)) {
618 WriteLineInd ("else {");
619 WriteLine ("WriteTypedPrimitive (element, namesp, ob, true);");
620 WriteLine ("return;");
621 WriteLineUni ("}");
622 }
623 else
624 {
625 WriteLineInd ("else {");
626 WriteLine ("throw CreateUnknownTypeException (ob);");
627 WriteLineUni ("}");
628 WriteLine ("");
629
630 WriteLineInd ("if (writeWrappingElem) {");
631 if (_format == SerializationFormat.Encoded) WriteLine ("needType = true;");
632 WriteLine ("WriteStartElement (element, namesp, ob);");
633 WriteLineUni ("}");
634 WriteLine ("");
635
636 WriteLine ("if (needType) WriteXsiType(" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.XmlTypeNamespace) + ");");
637 WriteLine ("");
638
639 switch (typeMap.TypeData.SchemaType)
640 {
641 case SchemaTypes.Class: GenerateWriteObjectElement (typeMap, "ob", false); break;
642 case SchemaTypes.Array: GenerateWriteListElement (typeMap, "ob"); break;
643 case SchemaTypes.Primitive: GenerateWritePrimitiveElement (typeMap, "ob"); break;
644 case SchemaTypes.Enum: GenerateWriteEnumElement (typeMap, "ob"); break;
645 }
646
647 WriteLine ("if (writeWrappingElem) WriteEndElement (ob);");
648 }
649
650 GenerateEndHook ();
651 WriteLineUni ("}");
652 WriteLine ("");
653 PopHookContext ();
654 }
655
656 void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
657 {
658 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
659 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
660
661 ClassMap map = (ClassMap)xmlMap.ObjectMap;
662 if (!GenerateWriteHook (HookType.attributes, xmlMapType))
663 {
664 if (map.NamespaceDeclarations != null) {
665 WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
666 WriteLine ("");
667 }
668
669 ICollection attributes = map.AttributeMembers;
670 if (attributes != null)
671 {
672 foreach (XmlTypeMapMemberAttribute attr in attributes)
673 {
674 if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
675
676 string val = GenerateGetMemberValue (attr, ob, isValueList);
677 string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
678
679 if (cond != null) WriteLineInd ("if (" + cond + ") {");
680
681 string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val);
682 WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
683
684 if (cond != null) WriteLineUni ("}");
685 GenerateEndHook ();
686 }
687 WriteLine ("");
688 }
689
690 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
691 if (anyAttrMember != null)
692 {
693 if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
694 {
695 string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
696 if (cond != null) WriteLineInd ("if (" + cond + ") {");
697
698 string tmpVar = GetObTempVar ();
699 WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
700 WriteLineInd ("if (" + tmpVar + " != null) {");
701
702 string tmpVar2 = GetObTempVar ();
703 WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
704 WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
705 Unindent ();
706 WriteLineUni ("}");
707
708 if (cond != null) WriteLineUni ("}");
709 WriteLine ("");
710 GenerateEndHook ();
711 }
712 }
713 GenerateEndHook ();
714 }
715
716 if (!GenerateWriteHook (HookType.elements, xmlMapType))
717 {
718 ICollection members = map.ElementMembers;
719 if (members != null)
720 {
721 foreach (XmlTypeMapMemberElement member in members)
722 {
723 if (GenerateWriteMemberHook (xmlMapType, member)) continue;
724
725 string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
726 if (cond != null) WriteLineInd ("if (" + cond + ") {");
727
728 string memberValue = GenerateGetMemberValue (member, ob, isValueList);
729 Type memType = member.GetType();
730
731 if (memType == typeof(XmlTypeMapMemberList))
732 {
733 GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
734 }
735 else if (memType == typeof(XmlTypeMapMemberFlatList))
736 {
737 WriteLineInd ("if (" + memberValue + " != null) {");
738 GenerateWriteListContent (member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
739 WriteLineUni ("}");
740 }
741 else if (memType == typeof(XmlTypeMapMemberAnyElement))
742 {
743 WriteLineInd ("if (" + memberValue + " != null) {");
744 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
745 WriteLineUni ("}");
746 }
747 else if (memType == typeof(XmlTypeMapMemberAnyElement))
748 {
749 WriteLineInd ("if (" + memberValue + " != null) {");
750 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
751 WriteLineUni ("}");
752 }
753 else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
754 {
755 // Ignore
756 }
757 else if (memType == typeof(XmlTypeMapMemberElement))
758 {
759 if (member.ElementInfo.Count == 1) {
760 GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
761 }
762 else if (member.ChoiceMember != null)
763 {
764 string choiceValue = ob + ".@" + member.ChoiceMember;
765 foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
766 WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
767 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
768 WriteLineUni ("}");
769 }
770 }
771 else
772 {
773 // WriteLineInd ("if (" + memberValue + " == null) {");
774 // GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
775 // WriteLineUni ("}");
776
777 bool first = true;
778 Type type = memberValue.GetType();
779 foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
780 {
781 WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.FullTypeName + ") {");
782 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
783 WriteLineUni ("}");
784 first = false;
785 }
786 }
787 }
788 else
789 throw new InvalidOperationException ("Unknown member type");
790
791 if (cond != null)
792 WriteLineUni ("}");
793
794 GenerateEndHook ();
795 }
796 }
797 GenerateEndHook ();
798 }
799 }
800
801 void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
802 {
803 switch (elem.TypeData.SchemaType)
804 {
805 case SchemaTypes.XmlNode:
806 string elemName = elem.WrappedElement ? elem.ElementName : "";
807 if (_format == SerializationFormat.Literal)
808 WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
809 else
810 WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
811 break;
812
813 case SchemaTypes.Enum:
814 case SchemaTypes.Primitive:
815 if (_format == SerializationFormat.Literal)
816 GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
817 else
818 GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
819 break;
820
821 case SchemaTypes.Array:
822 WriteLineInd ("if (" + memberValue + " != null) {");
823
824 if (elem.MappedType.MultiReferenceType) {
825 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
826 RegisterReferencingMap (elem.MappedType);
827 }
828 else {
829 WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
830 GenerateWriteListContent (elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
831 WriteMetCall ("WriteEndElement", memberValue);
832 }
833 WriteLineUni ("}");
834
835 if (elem.IsNullable) {
836 WriteLineInd ("else");
837 if (_format == SerializationFormat.Literal)
838 WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
839 else
840 WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
841 Unindent ();
842 }
843
844 break;
845
846 case SchemaTypes.Class:
847 if (elem.MappedType.MultiReferenceType) {
848 RegisterReferencingMap (elem.MappedType);
849 if (elem.MappedType.TypeData.Type == typeof(object))
850 WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
851 else
852 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
853 }
854 else
855 WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
856 break;
857
858 case SchemaTypes.XmlSerializable:
859 WriteMetCall ("WriteSerializable", memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
860 break;
861
862 default:
863 throw new NotSupportedException ("Invalid value type");
864 }
865 }
866
867 void GenerateWriteListElement (XmlTypeMapping typeMap, string ob)
868 {
869 if (_format == SerializationFormat.Encoded)
870 {
871 string n, ns;
872 string itemCount = GenerateGetListCount (typeMap.TypeData, ob);
873 GenerateGetArrayType ((ListMap) typeMap.ObjectMap, itemCount, out n, out ns);
874
875 string arrayType;
876 if (ns != string.Empty)
877 arrayType = "FromXmlQualifiedName (new XmlQualifiedName(" + n + "," + ns + "))";
878 else
879 arrayType = GetLiteral (n);
880
881 WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
882 }
883 GenerateWriteListContent (typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
884 }
885
886 void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
887 {
888 bool singleElement = (member.TypeData.Type == typeof (XmlElement));
889 string var;
890
891 if (singleElement)
892 var = memberValue;
893 else {
894 var = GetObTempVar ();
895 WriteLineInd ("foreach (XmlNode " + var + " in " + memberValue + ") {");
896 }
897
898 string elem = GetObTempVar ();
899 WriteLine ("XmlElement " + elem + " = " + var + " as XmlElement;");
900 WriteLine ("if (" + elem + " == null) throw CreateUnknownTypeException (" + elem + ");");
901
902 if (!member.IsDefaultAny) {
903 for (int n=0; n<member.ElementInfo.Count; n++) {
904 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)member.ElementInfo[n];
905 string txt = "(" + elem + ".Name == " + GetLiteral(info.ElementName) + " && " + elem + ".NamespaceURI == " + GetLiteral(info.Namespace) + ")";
906 if (n == member.ElementInfo.Count-1) txt += ") {";
907 if (n == 0) WriteLineInd ("if (" + txt);
908 else WriteLine ("|| " + txt);
909 }
910 }
911
912 if (_format == SerializationFormat.Literal)
913 WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
914 else
915 WriteLine ("WriteElementEncoded (" + elem + ", \"\", \"\", false, true);");
916
917 if (!member.IsDefaultAny) {
918 WriteLineUni ("}");
919 WriteLineInd ("else");
920 WriteLine ("throw CreateUnknownAnyElementException (" + elem + ".Name, " + elem + ".NamespaceURI);");
921 Unindent ();
922 }
923
924 if (!singleElement)
925 WriteLineUni ("}");
926 }
927
928 void GenerateWritePrimitiveElement (XmlTypeMapping typeMap, string ob)
929 {
930 string strVal = GenerateGetStringValue (typeMap, typeMap.TypeData, ob);
931 WriteLine ("Writer.WriteString (" + strVal + ");");
932 }
933
934 void GenerateWriteEnumElement (XmlTypeMapping typeMap, string ob)
935 {
936 string strVal = GenerateGetEnumXmlValue (typeMap, ob);
937 WriteLine ("Writer.WriteString (" + strVal + ");");
938 }
939
940 string GenerateGetStringValue (XmlTypeMapping typeMap, TypeData type, string value)
941 {
942 if (type.SchemaType == SchemaTypes.Array) {
943 string str = GetStrTempVar ();
944 WriteLine ("string " + str + " = null;");
945 WriteLineInd ("if (" + value + " != null) {");
946 string res = GenerateWriteListContent (typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
947 WriteLine (str + " = " + res + ".ToString ().Trim ();");
948 WriteLineUni ("}");
949 return str;
950 }
951 else if (type.SchemaType == SchemaTypes.Enum) {
952 return GenerateGetEnumXmlValue (typeMap, value);
953 }
954 else if (type.Type == typeof (XmlQualifiedName))
955 return "FromXmlQualifiedName (" + value + ")";
956 else if (value == null)
957 return null;
958 else
959 return XmlCustomFormatter.GenerateToXmlString (type, value);
960 }
961
962 string GenerateGetEnumXmlValue (XmlTypeMapping typeMap, string ob)
963 {
964 return GetGetEnumValueName (typeMap) + " (" + ob + ")";
965 }
966
967 string GenerateGetListCount (TypeData listType, string ob)
968 {
969 if (listType.Type.IsArray)
970 return "ob.Length";
971 else
972 return "ob.Count";
973 }
974
975 void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns)
976 {
977 string arrayDim;
978 if (itemCount != "") arrayDim = "";
979 else arrayDim = "[]";
980
981 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0];
982 if (info.TypeData.SchemaType == SchemaTypes.Array)
983 {
984 string nm;
985 GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns);
986 localName = nm + arrayDim;
987 }
988 else
989 {
990 if (info.MappedType != null)
991 {
992 localName = info.MappedType.XmlType + arrayDim;
993 ns = info.MappedType.Namespace;
994 }
995 else
996 {
997 localName = info.TypeData.XmlType + arrayDim;
998 ns = info.DataTypeNamespace;
999 }
1000 }
1001 if (itemCount != "") {
1002 localName = "\"" + localName + "[\" + " + itemCount + " + \"]\"";
1003 ns = GetLiteral (ns);
1004 }
1005 }
1006
1007 string GenerateWriteListContent (TypeData listType, ListMap map, string ob, bool writeToString)
1008 {
1009 string targetString = null;
1010
1011 if (writeToString)
1012 {
1013 targetString = GetStrTempVar ();
1014 WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();");
1015 }
1016
1017 if (listType.Type.IsArray)
1018 {
1019 string itemVar = GetNumTempVar ();
1020 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
1021 GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
1022 WriteLineUni ("}");
1023 }
1024 else if (typeof(ICollection).IsAssignableFrom (listType.Type))
1025 {
1026 string itemVar = GetNumTempVar ();
1027 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
1028 GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
1029 WriteLineUni ("}");
1030 }
1031 else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
1032 {
1033 string itemVar = GetObTempVar ();
1034 WriteLineInd ("foreach (" + listType.ListItemTypeData.FullTypeName + " " + itemVar + " in " + ob + ") {");
1035 GenerateListLoop (map, itemVar, listType.ListItemTypeData, targetString);
1036 WriteLineUni ("}");
1037 }
1038 else
1039 throw new Exception ("Unsupported collection type");
1040
1041 return targetString;
1042 }
1043
1044 void GenerateListLoop (ListMap map, string item, TypeData itemTypeData, string targetString)
1045 {
1046 bool multichoice = (map.ItemInfo.Count > 1);
1047
1048 if (multichoice)
1049 WriteLine ("if (" + item + " == null) { }");
1050
1051 foreach (XmlTypeMapElementInfo info in map.ItemInfo)
1052 {
1053 if (multichoice)
1054 WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.FullTypeName + ")) {");
1055
1056 if (targetString == null)
1057 GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
1058 else
1059 {
1060 string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item));
1061 WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");");
1062 }
1063
1064 if (multichoice)
1065 WriteLineUni ("}");
1066 }
1067
1068 if (multichoice)
1069 WriteLine ("else throw CreateUnknownTypeException (" + item + ");");
1070 }
1071
1072 void GenerateWritePrimitiveValueLiteral (string memberValue, string name, string ns, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1073 {
1074 if (!wrapped) {
1075 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1076 WriteMetCall ("WriteValue", strVal);
1077 }
1078 else if (isNullable) {
1079 if (typeData.Type == typeof(XmlQualifiedName))
1080 WriteMetCall ("WriteNullableQualifiedNameLiteral", GetLiteral(name), GetLiteral(ns), memberValue);
1081 else {
1082 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1083 WriteMetCall ("WriteNullableStringLiteral", GetLiteral(name), GetLiteral(ns), strVal);
1084 }
1085 }
1086 else {
1087 if (typeData.Type == typeof(XmlQualifiedName))
1088 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue);
1089 else {
1090 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1091 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal);
1092 }
1093 }
1094 }
1095
1096 void GenerateWritePrimitiveValueEncoded (string memberValue, string name, string ns, XmlQualifiedName xsiType, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1097 {
1098 if (!wrapped) {
1099 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1100 WriteMetCall ("WriteValue", strVal);
1101 }
1102 else if (isNullable) {
1103 if (typeData.Type == typeof(XmlQualifiedName))
1104 WriteMetCall ("WriteNullableQualifiedNameEncoded", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1105 else {
1106 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1107 WriteMetCall ("WriteNullableStringEncoded", GetLiteral(name), GetLiteral(ns), strVal, GetLiteral(xsiType));
1108 }
1109 }
1110 else {
1111 if (typeData.Type == typeof(XmlQualifiedName))
1112 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1113 else {
1114 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1115 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal, GetLiteral(xsiType));
1116 }
1117 }
1118 }
1119
1120 string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
1121 {
1122 if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.Index + "]");
1123 else return ob + ".@" + member.Name;
1124 }
1125
1126 string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
1127 {
1128 if (isValueList) {
1129 return ob + ".Length > " + member.Index;
1130 }
1131 else if (member.DefaultValue != System.DBNull.Value) {
1132 string mem = ob + ".@" + member.Name;
1133 if (member.DefaultValue == null)
1134 return mem + " != null";
1135 else if (member.TypeData.SchemaType == SchemaTypes.Enum)
1136 return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
1137 else
1138 return mem + " != " + GetLiteral (member.DefaultValue);
1139 }
1140 else if (member.IsOptionalValueType)
1141 return ob + ".@" + member.Name + "Specified";
1142 return null;
1143 }
1144
1145 void GenerateWriteInitCallbacks ()
1146 {
1147 WriteLine ("protected override void InitCallbacks ()");
1148 WriteLineInd ("{");
1149
1150 if (_format == SerializationFormat.Encoded)
1151 {
1152 foreach (XmlMapping xmap in _mapsToGenerate) {
1153 XmlTypeMapping map = xmap as XmlTypeMapping;
1154 if (map != null)
1155 WriteMetCall ("AddWriteCallback", GetTypeOf(map.TypeData), GetLiteral(map.XmlType), GetLiteral(map.Namespace), "new XmlSerializationWriteCallback (" + GetWriteObjectCallbackName (map) + ")");
1156 }
1157 }
1158
1159 WriteLineUni ("}");
1160 WriteLine ("");
1161
1162 if (_format == SerializationFormat.Encoded)
1163 {
1164 foreach (XmlTypeMapping xmap in _mapsToGenerate) {
1165 XmlTypeMapping map = xmap as XmlTypeMapping;
1166 if (map == null) continue;
1167 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1168 WriteWriteEnumCallback (map);
1169 else
1170 WriteWriteObjectCallback (map);
1171 }
1172 }
1173 }
1174
1175 void WriteWriteEnumCallback (XmlTypeMapping map)
1176 {
1177 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1178 WriteLineInd ("{");
1179 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "true", "false");
1180 WriteLineUni ("}");
1181 WriteLine ("");
1182 }
1183
1184 void WriteWriteObjectCallback (XmlTypeMapping map)
1185 {
1186 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1187 WriteLineInd ("{");
1188 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "false", "false");
1189 WriteLineUni ("}");
1190 WriteLine ("");
1191 }
1192
1193 #endregion
1194
1195 #region Reader Generation
1196
1197 //*******************************************************
1198 // Reader generation
1199 //
1200
1201 public void GenerateReader (string readerClassName, ArrayList maps)
1202 {
1203 WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
1204 WriteLineInd ("{");
1205
1206 _mapsToGenerate = new ArrayList ();
1207 _fixupCallbacks = new ArrayList ();
1208 InitHooks ();
1209
1210 for (int n=0; n<maps.Count; n++)
1211 {
1212 GenerationResult res = (GenerationResult) maps [n];
1213 _typeMap = res.Mapping;
1214 _format = _typeMap.Format;
1215 _result = res;
1216
1217 GenerateReadRoot ();
1218 }
1219
1220 for (int n=0; n<_mapsToGenerate.Count; n++)
1221 {
1222 XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
1223 if (map == null) continue;
1224
1225 GenerateReadObject (map);
1226 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1227 GenerateGetEnumValue (map);
1228 }
1229
1230 GenerateReadInitCallbacks ();
1231
1232 if (_format == SerializationFormat.Encoded)
1233 {
1234 GenerateFixupCallbacks ();
1235 GenerateFillerCallbacks ();
1236 }
1237
1238 WriteLineUni ("}");
1239 UpdateGeneratedTypes (_mapsToGenerate);
1240 }
1241
1242 void GenerateReadRoot ()
1243 {
1244 WriteLine ("public object " + _result.ReadMethodName + " ()");
1245 WriteLineInd ("{");
1246 WriteLine ("Reader.MoveToContent();");
1247
1248 if (_typeMap is XmlTypeMapping)
1249 {
1250 XmlTypeMapping typeMap = (XmlTypeMapping) _typeMap;
1251 // Console.WriteLine ("> " + typeMap.TypeName);
1252
1253 if (_format == SerializationFormat.Literal)
1254 {
1255 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
1256 throw new Exception ("Not supported for XmlNode types");
1257
1258 // Console.WriteLine ("This should be string:" + typeMap.ElementName.GetType());
1259 WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
1260 WriteLine ("throw CreateUnknownNodeException();");
1261 Unindent ();
1262
1263 WriteLine ("return " + GetReadObjectCall (typeMap, "true", "true") + ";");
1264 }
1265 else
1266 {
1267 WriteLine ("object ob = null;");
1268 WriteLine ("Reader.MoveToContent();");
1269 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1270 WriteLineInd ("{");
1271 WriteLineInd ("if (Reader.LocalName == " + GetLiteral(typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
1272 WriteLine ("ob = ReadReferencedElement();");
1273 Unindent ();
1274 WriteLineInd ("else ");
1275 WriteLine ("throw CreateUnknownNodeException();");
1276 Unindent ();
1277 WriteLineUni ("}");
1278 WriteLineInd ("else ");
1279 WriteLine ("UnknownNode(null);");
1280 Unindent ();
1281 WriteLine ("");
1282 WriteLine ("ReadReferencedElements();");
1283 WriteLine ("return ob;");
1284 RegisterReferencingMap (typeMap);
1285 }
1286 }
1287 else {
1288 WriteLine ("return " + GenerateReadMessage ((XmlMembersMapping)_typeMap) + ";");
1289 }
1290
1291 WriteLineUni ("}");
1292 WriteLine ("");
1293 }
1294
1295 string GenerateReadMessage (XmlMembersMapping typeMap)
1296 {
1297 WriteLine ("object[] parameters = new object[" + typeMap.Count + "];");
1298 WriteLine ("");
1299
1300 if (typeMap.HasWrapperElement)
1301 {
1302 if (_format == SerializationFormat.Encoded)
1303 {
1304 WriteLine ("while (Reader.NodeType == System.Xml.XmlNodeType.Element)");
1305 WriteLineInd ("{");
1306 WriteLine ("string root = Reader.GetAttribute (\"root\", " + GetLiteral(XmlSerializer.EncodingNamespace) + ");");
1307 WriteLine ("if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;");
1308 WriteLine ("ReadReferencedElement ();");
1309 WriteLine ("Reader.MoveToContent ();");
1310 WriteLineUni ("}");
1311 WriteLine ("");
1312 WriteLine ("if (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1313 WriteLineInd ("{");
1314 WriteLineInd ("if (Reader.IsEmptyElement) {");
1315 WriteLine ("Reader.Skip();");
1316 WriteLineUni ("}");
1317 WriteLineInd ("else {");
1318 WriteLine ("Reader.ReadStartElement();");
1319 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1320 WriteLine ("ReadEndElement();");
1321 WriteLineUni ("}");
1322 WriteLine ("");
1323 WriteLine ("Reader.MoveToContent();");
1324 WriteLineUni ("}");
1325 }
1326 else
1327 {
1328 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1329 WriteLineInd ("{");
1330 WriteLine ("if (Reader.IsStartElement(" + GetLiteral(typeMap.ElementName) + ", " + GetLiteral(typeMap.Namespace) + "))");
1331 WriteLineInd ("{");
1332 WriteLine ("if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }");
1333 WriteLine ("Reader.ReadStartElement();");
1334 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1335 WriteLine ("ReadEndElement();");
1336 WriteLine ("break;");
1337 WriteLineUni ("}");
1338 WriteLineInd ("else ");
1339 WriteLine ("UnknownNode(null);");
1340 Unindent ();
1341 WriteLine ("");
1342 WriteLine ("Reader.MoveToContent();");
1343 WriteLineUni ("}");
1344 }
1345 }
1346 else
1347 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, _format == SerializationFormat.Encoded);
1348
1349 if (_format == SerializationFormat.Encoded)
1350 WriteLine ("ReadReferencedElements();");
1351
1352 return "parameters";
1353 }
1354
1355 void GenerateReadObject (XmlTypeMapping typeMap)
1356 {
1357 string isNullable;
1358 if (_format == SerializationFormat.Literal) {
1359 WriteLine ("public " + typeMap.TypeFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
1360 isNullable = "isNullable";
1361 }
1362 else {
1363 WriteLine ("public object " + GetReadObjectName (typeMap) + " ()");
1364 isNullable = "true";
1365 }
1366
1367 WriteLineInd ("{");
1368
1369 PushHookContext ();
1370
1371 SetHookVar ("$TYPE", typeMap.TypeName);
1372 SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
1373 SetHookVar ("$NULLABLE", "isNullable");
1374
1375 switch (typeMap.TypeData.SchemaType)
1376 {
1377 case SchemaTypes.Class: GenerateReadClassInstance (typeMap, isNullable, "checkType"); break;
1378 case SchemaTypes.Array:
1379 WriteLine ("return " + GenerateReadListElement (typeMap, null, isNullable, true) + ";");
1380 break;
1381 case SchemaTypes.XmlNode: GenerateReadXmlNodeElement (typeMap, isNullable); break;
1382 case SchemaTypes.Primitive: GenerateReadPrimitiveElement (typeMap, isNullable); break;
1383 case SchemaTypes.Enum: GenerateReadEnumElement (typeMap, isNullable); break;
1384 case SchemaTypes.XmlSerializable: GenerateReadXmlSerializableElement (typeMap, isNullable); break;
1385 default: throw new Exception ("Unsupported map type");
1386 }
1387
1388 WriteLineUni ("}");
1389 WriteLine ("");
1390 PopHookContext ();
1391 }
1392
1393 void GenerateReadClassInstance (XmlTypeMapping typeMap, string isNullable, string checkType)
1394 {
1395 SetHookVar ("$OBJECT", "ob");
1396 if (!typeMap.TypeData.IsValueType)
1397 {
1398 WriteLine (typeMap.TypeFullName + " ob = null;");
1399
1400 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1401 WriteLine ("return ob;");
1402 return;
1403 }
1404
1405 if (_format == SerializationFormat.Literal) {
1406 WriteLine ("if (" + isNullable + " && ReadNull()) return null;");
1407 WriteLine ("");
1408 WriteLine ("if (checkType) ");
1409 WriteLineInd ("{");
1410 }
1411 else {
1412 WriteLine ("if (ReadNull()) return null;");
1413 WriteLine ("");
1414 }
1415 }
1416 else
1417 {
1418 WriteLine (typeMap.TypeFullName + " ob = new " + typeMap.TypeFullName + " ();");
1419
1420 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1421 WriteLine ("return ob;");
1422 return;
1423 }
1424 }
1425
1426 WriteLine ("System.Xml.XmlQualifiedName t = GetXsiType();");
1427 WriteLine ("if (t == null)");
1428 if (typeMap.TypeData.Type != typeof(object))
1429 WriteLine ("\t;");
1430 else
1431 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (new System.Xml.XmlQualifiedName(\"anyType\", System.Xml.Schema.XmlSchema.Namespace))") + ";");
1432
1433 foreach (XmlTypeMapping realMap in typeMap.DerivedTypes)
1434 {
1435 WriteLineInd ("else if (t.Name == " + GetLiteral (realMap.XmlType) + " && t.Namespace == " + GetLiteral (realMap.XmlTypeNamespace) + ")");
1436 WriteLine ("return " + GetReadObjectCall(realMap, isNullable, checkType) + ";");
1437 Unindent ();
1438 }
1439
1440 WriteLine ("else if (t.Name != " + GetLiteral (typeMap.XmlType) + " || t.Namespace != " + GetLiteral (typeMap.XmlTypeNamespace) + ")");
1441 if (typeMap.TypeData.Type == typeof(object))
1442 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
1443 else
1444 WriteLine ("\tthrow CreateUnknownTypeException(t);");
1445
1446 if (!typeMap.TypeData.IsValueType)
1447 {
1448 if (_format == SerializationFormat.Literal)
1449 WriteLineUni ("}");
1450
1451 if (typeMap.TypeData.Type.IsAbstract) {
1452 GenerateEndHook ();
1453 WriteLine ("return ob;");
1454 return;
1455 }
1456
1457 WriteLine ("");
1458 WriteLine ("ob = new " + typeMap.TypeFullName + " ();");
1459 }
1460
1461 WriteLine ("");
1462
1463 WriteLine ("Reader.MoveToElement();");
1464 WriteLine ("");
1465
1466 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "ob", false, false);
1467
1468 WriteLine ("");
1469
1470 GenerateEndHook ();
1471 WriteLine ("return ob;");
1472 }
1473
1474 void GenerateReadMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, bool readByOrder)
1475 {
1476 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
1477 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
1478
1479 // Load the default value of members
1480 if (map.MembersWithDefault != null)
1481 {
1482 ArrayList members = map.MembersWithDefault;
1483 for (int n=0; n<members.Count; n++) {
1484 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
1485 GenerateSetMemberValueFromAttr (mem, ob, GetLiteral (mem.DefaultValue), isValueList);
1486 }
1487 }
1488
1489 // A value list cannot have attributes
1490
1491 bool first;
1492 if (!isValueList && !GenerateReadHook (HookType.attributes, xmlMapType))
1493 {
1494 // Reads attributes
1495
1496 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
1497
1498 if (anyAttrMember != null)
1499 {
1500 WriteLine ("int anyAttributeIndex = 0;");
1501 WriteLine (anyAttrMember.TypeData.FullTypeName + " anyAttributeArray = null;");
1502 }
1503
1504 WriteLine ("while (Reader.MoveToNextAttribute())");
1505 WriteLineInd ("{");
1506 first = true;
1507 if (map.AttributeMembers != null) {
1508 foreach (XmlTypeMapMemberAttribute at in map.AttributeMembers)
1509 {
1510 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (at.AttributeName) + " && Reader.NamespaceURI == " + GetLiteral (at.Namespace) + ") {");
1511 if (!GenerateReadMemberHook (xmlMapType, at)) {
1512 GenerateSetMemberValue (at, ob, GenerateGetValueFromXmlString ("Reader.Value", at.TypeData, at.MappedType), isValueList);
1513 GenerateEndHook ();
1514 }
1515 WriteLineUni ("}");
1516 first = false;
1517 }
1518 }
1519 WriteLineInd ((first?"":"else ") + "if (IsXmlnsAttribute (Reader.Name)) {");
1520
1521 // If the map has NamespaceDeclarations,
1522 // then store this xmlns to the given member.
1523 // If the instance doesn't exist, then create.
1524
1525 if (map.NamespaceDeclarations != null) {
1526 if (!GenerateReadMemberHook (xmlMapType, map.NamespaceDeclarations)) {
1527 string nss = ob + ".@" + map.NamespaceDeclarations.Name;
1528 WriteLine ("if (" + nss + " == null) " + nss + " = new XmlSerializerNamespaces ();");
1529 WriteLineInd ("if (Reader.Prefix == \"xmlns\")");
1530 WriteLine (nss + ".Add (Reader.LocalName, Reader.Value);");
1531 Unindent ();
1532 WriteLineInd ("else");
1533 WriteLine (nss + ".Add (\"\", Reader.Value);");
1534 Unindent ();
1535 GenerateEndHook ();
1536 }
1537 }
1538
1539 WriteLineUni ("}");
1540 WriteLineInd ("else {");
1541
1542 if (anyAttrMember != null)
1543 {
1544 if (!GenerateReadArrayMemberHook (xmlMapType, anyAttrMember, "anyAttributeIndex")) {
1545 WriteLine ("System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);");
1546 if (typeof(System.Xml.Schema.XmlSchemaAnnotated).IsAssignableFrom (xmlMapType))
1547 WriteLine ("ParseWsdlArrayType (attr);");
1548 GenerateAddListValue (anyAttrMember.TypeData, "anyAttributeArray", "anyAttributeIndex", GetCast (anyAttrMember.TypeData.ListItemTypeData, "attr"), true);
1549 GenerateEndHook ();
1550 }
1551 WriteLine ("anyAttributeIndex++;");
1552 }
1553 else {
1554 if (!GenerateReadHook (HookType.unknownAttribute, xmlMapType)) {
1555 WriteLine ("UnknownNode (" + ob + ");");
1556 GenerateEndHook ();
1557 }
1558 }
1559
1560 WriteLineUni ("}");
1561 WriteLineUni ("}");
1562
1563 if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
1564 {
1565 WriteLine ("");
1566 WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.FullTypeName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
1567 GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
1568 }
1569 WriteLine ("");
1570
1571 GenerateEndHook ();
1572 }
1573
1574 if (!isValueList)
1575 {
1576 WriteLine ("Reader.MoveToElement();");
1577 WriteLineInd ("if (Reader.IsEmptyElement) {");
1578 WriteLine ("Reader.Skip ();");
1579 WriteLine ("return " + ob + ";");
1580 WriteLineUni ("}");
1581 WriteLine ("");
1582
1583 WriteLine ("Reader.ReadStartElement();");
1584 }
1585
1586 // Reads elements
1587
1588 WriteLine("Reader.MoveToContent();");
1589 WriteLine ("");
1590
1591 if (!GenerateReadHook (HookType.elements, xmlMapType))
1592 {
1593 string[] readFlag = null;
1594 if (map.ElementMembers != null && !readByOrder)
1595 {
1596 string readFlagsVars = "bool ";
1597 readFlag = new string[map.ElementMembers.Count];
1598 for (int n=0; n<map.ElementMembers.Count; n++) {
1599 readFlag[n] = GetBoolTempVar ();
1600 if (n > 0) readFlagsVars += ", ";
1601 readFlagsVars += readFlag[n] + "=false";
1602 }
1603 if (map.ElementMembers.Count > 0) WriteLine (readFlagsVars + ";");
1604 WriteLine ("");
1605 }
1606
1607 string[] indexes = null;
1608 string[] flatLists = null;
1609
1610 if (map.FlatLists != null)
1611 {
1612 indexes = new string[map.FlatLists.Count];
1613 flatLists = new string[map.FlatLists.Count];
1614
1615 string code = "int ";
1616 for (int n=0; n<map.FlatLists.Count; n++)
1617 {
1618 XmlTypeMapMember mem = (XmlTypeMapMember)map.FlatLists[n];
1619 indexes[n] = GetNumTempVar ();
1620 if (n > 0) code += ", ";
1621 code += indexes[n] + "=0";
1622 if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
1623 flatLists[n] = GetObTempVar ();
1624 string rval = "null";
1625 if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) rval = ob + ".@" + mem.Name;
1626 WriteLine (mem.TypeData.FullTypeName + " " + flatLists[n] + " = " + rval + ";");
1627 }
1628 }
1629 WriteLine (code + ";");
1630 WriteLine ("");
1631 }
1632
1633 if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
1634 {
1635 _fixupCallbacks.Add (xmlMap);
1636 WriteLine ("Fixup fixup = new Fixup(" + ob + ", new XmlSerializationFixupCallback(" + GetFixupCallbackName (xmlMap) + "), " + map.ElementMembers.Count + ");");
1637 WriteLine ("AddFixup (fixup);");
1638 WriteLine ("");
1639 }
1640
1641 ArrayList infos = null;
1642
1643 int maxInd;
1644 if (readByOrder) {
1645 if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
1646 else maxInd = 0;
1647 }
1648 else
1649 {
1650 infos = new ArrayList ();
1651 infos.AddRange (map.AllElementInfos);
1652 maxInd = infos.Count;
1653
1654 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
1655 WriteLineInd ("{");
1656 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1657 WriteLineInd ("{");
1658 }
1659
1660 first = true;
1661 for (int ind = 0; ind < maxInd; ind++)
1662 {
1663 XmlTypeMapElementInfo info = readByOrder ? map.GetElement (ind) : (XmlTypeMapElementInfo) infos [ind];
1664
1665 if (!readByOrder)
1666 {
1667 if (info.IsTextElement || info.IsUnnamedAnyElement) continue;
1668 string elemCond = first ? "" : "else ";
1669 elemCond += "if (";
1670 if (!(info.Member.IsReturnValue && _format == SerializationFormat.Encoded)) {
1671 elemCond += "Reader.LocalName == " + GetLiteral (info.ElementName);
1672 if (!map.IgnoreMemberNamespace) elemCond += " && Reader.NamespaceURI == " + GetLiteral (info.Namespace);
1673 elemCond += " && ";
1674 }
1675 elemCond += "!" + readFlag[info.Member.Index] + ") {";
1676 WriteLineInd (elemCond);
1677 }
1678
1679 if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
1680 {
1681 if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
1682 {
1683 string list = GetObTempVar ();
1684 WriteLine ("object " + list + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1685 RegisterReferencingMap (info.MappedType);
1686
1687 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // Already read
1688 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1689 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.FullTypeName) + ");");
1690 else
1691 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1692 WriteLineUni ("}");
1693
1694 if (!info.MappedType.TypeData.Type.IsArray)
1695 {
1696 WriteLineInd ("else {");
1697 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1698 WriteLine (list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1699 else {
1700 WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1701 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1702 }
1703 WriteLine ("AddFixup (new CollectionFixup (" + list + ", new XmlSerializationCollectionFixupCallback (" + GetFillListName(info.Member.TypeData) + "), fixup.Ids[" + info.Member.Index + "]));");
1704 WriteLine ("fixup.Ids[" + info.Member.Index + "] = null;"); // The member already has the value, no further fix needed.
1705 WriteLineUni ("}");
1706 }
1707 }
1708 else
1709 {
1710 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1711 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
1712 else GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
1713 GenerateEndHook ();
1714 }
1715 }
1716 if (!readByOrder)
1717 WriteLine (readFlag[info.Member.Index] + " = true;");
1718 }
1719 else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
1720 {
1721 XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
1722 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1723 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
1724 GenerateEndHook ();
1725 }
1726 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1727 }
1728 else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
1729 {
1730 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
1731 if (mem.TypeData.IsListType) {
1732 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1733 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
1734 GenerateEndHook ();
1735 }
1736 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1737 }
1738 else {
1739 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1740 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1741 GenerateEndHook ();
1742 }
1743 }
1744 }
1745 else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
1746 {
1747 if (!readByOrder)
1748 WriteLine (readFlag[info.Member.Index] + " = true;");
1749 if (_format == SerializationFormat.Encoded)
1750 {
1751 string val = GetObTempVar ();
1752 RegisterReferencingMap (info.MappedType);
1753
1754 if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
1755 WriteLine ("object " + val + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1756 else
1757 WriteLine ("object " + val + " = ReadReferencingElement (" + GetLiteral(info.Member.TypeData.XmlType) + ", " + GetLiteral(System.Xml.Schema.XmlSchema.Namespace) + ", out fixup.Ids[" + info.Member.Index + "]);");
1758
1759 if (info.MultiReferenceType)
1760 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // already read
1761 else
1762 WriteLineInd ("if (" + val + " != null) {"); // null value
1763
1764 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,val), isValueList);
1765 WriteLineUni ("}");
1766 }
1767 else if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1768 GenerateSetMemberValue (info.Member, ob, GenerateReadObjectElement (info), isValueList);
1769 GenerateEndHook ();
1770 }
1771 }
1772 else
1773 throw new InvalidOperationException ("Unknown member type");
1774
1775 if (!readByOrder)
1776 WriteLineUni ("}");
1777 first = false;
1778 }
1779
1780 if (!readByOrder)
1781 {
1782 if (!first) WriteLineInd ("else {");
1783
1784 if (map.DefaultAnyElementMember != null)
1785 {
1786 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
1787 if (mem.TypeData.IsListType) {
1788 if (!GenerateReadArrayMemberHook (xmlMapType, mem, indexes[mem.FlatArrayIndex])) {
1789 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
1790 GenerateEndHook ();
1791 }
1792 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1793 }
1794 else if (! GenerateReadMemberHook (xmlMapType, mem)) {
1795 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1796 GenerateEndHook ();
1797 }
1798 }
1799 else {
1800 if (!GenerateReadHook (HookType.unknownElement, xmlMapType)) {
1801 WriteLine ("UnknownNode (" + ob + ");");
1802 GenerateEndHook ();
1803 }
1804 }
1805
1806 if (!first) WriteLineUni ("}");
1807
1808 WriteLineUni ("}");
1809
1810 if (map.XmlTextCollector != null)
1811 {
1812 WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text)");
1813 WriteLineInd ("{");
1814
1815 if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
1816 {
1817 XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
1818 XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
1819 TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
1820
1821 if (!GenerateReadArrayMemberHook (xmlMapType, map.XmlTextCollector, indexes[mem.FlatArrayIndex])) {
1822 string val = (itype.Type == typeof (string)) ? "Reader.ReadString()" : GetReadXmlNode (itype, false);
1823 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], val, true);
1824 GenerateEndHook ();
1825 }
1826 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1827 }
1828 else if (!GenerateReadMemberHook (xmlMapType, map.XmlTextCollector))
1829 {
1830 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
1831 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
1832 if (info.TypeData.Type == typeof (string))
1833 GenerateSetMemberValue (mem, ob, "ReadString (" + GenerateGetMemberValue (mem, ob, isValueList) + ")", isValueList);
1834 else
1835 GenerateSetMemberValue (mem, ob, GenerateGetValueFromXmlString ("Reader.ReadString()", info.TypeData, info.MappedType), isValueList);
1836 GenerateEndHook ();
1837 }
1838 WriteLineUni ("}");
1839 }
1840
1841 WriteLine ("else");
1842 WriteLine ("\tUnknownNode(" + ob + ");");
1843 WriteLine ("");
1844 WriteLine ("Reader.MoveToContent();");
1845 WriteLineUni ("}");
1846 }
1847 else
1848 WriteLine ("Reader.MoveToContent();");
1849
1850 if (flatLists != null)
1851 {
1852 WriteLine ("");
1853 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
1854 {
1855 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
1856
1857 string list = flatLists[mem.FlatArrayIndex];
1858 if (mem.TypeData.Type.IsArray)
1859 WriteLine (list + " = (" + mem.TypeData.FullTypeName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
1860 if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
1861 GenerateSetMemberValue (mem, ob, list, isValueList);
1862 }
1863 }
1864 GenerateEndHook ();
1865 }
1866
1867 if (!isValueList)
1868 {
1869 WriteLine ("");
1870 WriteLine ("ReadEndElement();");
1871 }
1872 }
1873
1874 bool IsReadOnly (XmlTypeMapping map, XmlTypeMapMember member, TypeData memType, bool isValueList)
1875 {
1876 if (isValueList) return !memType.HasPublicConstructor;
1877 else return member.IsReadOnly (map.TypeData.Type) || !memType.HasPublicConstructor;
1878 }
1879
1880 void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
1881 {
1882 if (isValueList) WriteLine (ob + "[" + member.Index + "] = " + value + ";");
1883 else {
1884 WriteLine (ob + ".@" + member.Name + " = " + value + ";");
1885 if (member.IsOptionalValueType)
1886 WriteLine (ob + "." + member.Name + "Specified = true;");
1887 }
1888 }
1889
1890 void GenerateSetMemberValueFromAttr (XmlTypeMapMember member, string ob, string value, bool isValueList)
1891 {
1892 // Enumeration values specified in custom attributes are stored as integer
1893 // values if the custom attribute property is of type object. So, it is
1894 // necessary to convert to the enum type before asigning the value to the field.
1895
1896 if (member.TypeData.Type.IsEnum)
1897 value = GetCast (member.TypeData.Type, value);
1898 GenerateSetMemberValue (member, ob, value, isValueList);
1899 }
1900
1901 object GenerateGetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
1902 {
1903 if (isValueList) return ob + "[" + member.Index + "]";
1904 else return ob + ".@" + member.Name;
1905 }
1906
1907 string GenerateReadObjectElement (XmlTypeMapElementInfo elem)
1908 {
1909 switch (elem.TypeData.SchemaType)
1910 {
1911 case SchemaTypes.XmlNode:
1912 return GetReadXmlNode (elem.TypeData, true);
1913
1914 case SchemaTypes.Primitive:
1915 case SchemaTypes.Enum:
1916 return GenerateReadPrimitiveValue (elem);
1917
1918 case SchemaTypes.Array:
1919 return GenerateReadListElement (elem.MappedType, null, GetLiteral(elem.IsNullable), true);
1920
1921 case SchemaTypes.Class:
1922 return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
1923
1924 case SchemaTypes.XmlSerializable:
1925 return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.FullTypeName + " ())");
1926
1927 default:
1928 throw new NotSupportedException ("Invalid value type");
1929 }
1930 }
1931
1932 string GenerateReadPrimitiveValue (XmlTypeMapElementInfo elem)
1933 {
1934 if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
1935 if (elem.IsNullable) return "ReadNullableQualifiedName ()";
1936 else return "ReadElementQualifiedName ()";
1937 }
1938 else if (elem.IsNullable)
1939 return GenerateGetValueFromXmlString ("ReadNullableString ()", elem.TypeData, elem.MappedType);
1940 else
1941 return GenerateGetValueFromXmlString ("Reader.ReadElementString ()", elem.TypeData, elem.MappedType);
1942 }
1943
1944 string GenerateGetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
1945 {
1946 if (typeData.SchemaType == SchemaTypes.Array)
1947 return GenerateReadListString (typeMap, value);
1948 else if (typeData.SchemaType == SchemaTypes.Enum)
1949 return GenerateGetEnumValue (typeMap, value);
1950 else if (typeData.Type == typeof (XmlQualifiedName))
1951 return "ToXmlQualifiedName (" + value + ")";
1952 else
1953 return XmlCustomFormatter.GenerateFromXmlString (typeData, value);
1954 }
1955
1956 string GenerateReadListElement (XmlTypeMapping typeMap, string list, string isNullable, bool canCreateInstance)
1957 {
1958 Type listType = typeMap.TypeData.Type;
1959 ListMap listMap = (ListMap)typeMap.ObjectMap;
1960
1961 if (canCreateInstance && typeMap.TypeData.HasPublicConstructor)
1962 {
1963 list = GetObTempVar ();
1964 WriteLine (typeMap.TypeFullName + " " + list + " = null;");
1965 WriteLineInd ("if (!ReadNull()) {");
1966 WriteLine (list + " = " + GenerateCreateList (listType) + ";");
1967 }
1968 else
1969 {
1970 if (list != null) {
1971 WriteLineInd ("if (" + list + " == null)");
1972 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
1973 Unindent ();
1974 WriteLineInd ("if (!ReadNull()) {");
1975 }
1976 else {
1977 list = GetObTempVar ();
1978 WriteLine (typeMap.TypeFullName + " " + list + " = null;");
1979 WriteLineInd ("if (" + list + " == null)");
1980 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
1981 Unindent ();
1982 return list;
1983 }
1984 }
1985
1986 WriteLineInd ("if (Reader.IsEmptyElement) {");
1987 WriteLine ("Reader.Skip();");
1988 if (listType.IsArray)
1989 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
1990
1991 Unindent ();
1992 WriteLineInd ("} else {");
1993
1994 string index = GetNumTempVar ();
1995 WriteLine ("int " + index + " = 0;");
1996 WriteLine ("Reader.ReadStartElement();");
1997 WriteLine ("Reader.MoveToContent();");
1998 WriteLine ("");
1999
2000 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
2001 WriteLineInd ("{");
2002 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
2003 WriteLineInd ("{");
2004
2005 bool first = true;
2006 foreach (XmlTypeMapElementInfo elemInfo in listMap.ItemInfo)
2007 {
2008 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (elemInfo.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (elemInfo.Namespace) + ") {");
2009 GenerateAddListValue (typeMap.TypeData, list, index, GenerateReadObjectElement (elemInfo), false);
2010 WriteLine (index + "++;");
2011 WriteLineUni ("}");
2012 first = false;
2013 }
2014 if (!first) WriteLine ("else UnknownNode (null);");
2015 else WriteLine ("UnknownNode (null);");
2016
2017 WriteLineUni ("}");
2018 WriteLine ("else UnknownNode (null);");
2019 WriteLine ("");
2020 WriteLine ("Reader.MoveToContent();");
2021 WriteLineUni ("}");
2022
2023 WriteLine ("ReadEndElement();");
2024
2025 if (listType.IsArray)
2026 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
2027
2028 WriteLineUni ("}");
2029 WriteLineUni ("}");
2030
2031 return list;
2032 }
2033
2034 string GenerateReadListString (XmlTypeMapping typeMap, string values)
2035 {
2036 Type listType = typeMap.TypeData.Type;
2037 ListMap listMap = (ListMap)typeMap.ObjectMap;
2038 string itemType = listType.GetElementType().FullName;
2039
2040 string list = GetObTempVar ();
2041 WriteLine (itemType + "[] " + list + ";");
2042
2043 string var = GetStrTempVar ();
2044 WriteLine ("string " + var + " = " + values + ".Trim();");
2045 WriteLineInd ("if (" + var + " != string.Empty) {");
2046
2047 string valueArray = GetObTempVar ();
2048 WriteLine ("string[] " + valueArray + " = " + var + ".Split (' ');");
2049
2050 WriteLine (list + " = new " + itemType + " [" + valueArray + ".Length];");
2051
2052 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
2053
2054 string index = GetNumTempVar ();
2055 WriteLineInd ("for (int " + index + " = 0; " + index + " < " + valueArray + ".Length; " + index + "++)");
2056 WriteLine (list + "[" + index + "] = " + GenerateGetValueFromXmlString (valueArray + "[" + index + "]", info.TypeData, info.MappedType) + ";");
2057 Unindent ();
2058 WriteLineUni ("}");
2059 WriteLine ("else");
2060 WriteLine ("\t" + list + " = new " + itemType + " [0];");
2061
2062 return list;
2063 }
2064
2065 void GenerateAddListValue (TypeData listType, string list, string index, string value, bool canCreateInstance)
2066 {
2067 Type type = listType.Type;
2068 if (type.IsArray)
2069 {
2070 WriteLine (list + " = (" + type.FullName + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
2071 WriteLine (list + "[" + index + "] = " + value + ";");
2072 }
2073 else // Must be IEnumerable
2074 {
2075 WriteLine ("if (" + list + " == null)");
2076 if (canCreateInstance)
2077 WriteLine ("\t" + list + " = new " + listType.FullTypeName + "();");
2078 else
2079 WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.FullTypeName) + ");");
2080
2081 WriteLine (list + ".Add (" + value + ");");
2082 }
2083 }
2084
2085 string GenerateCreateList (Type listType)
2086 {
2087 if (listType.IsArray)
2088 return "(" + listType.FullName + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
2089 else
2090 return "new " + listType.FullName + "()";
2091 }
2092
2093 void GenerateFillerCallbacks ()
2094 {
2095 foreach (TypeData td in _listsToFill)
2096 {
2097 string metName = GetFillListName (td);
2098 WriteLine ("void " + metName + " (object list, object source)");
2099 WriteLineInd ("{");
2100 WriteLine ("if (list == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.FullTypeName) + ");");
2101 WriteLine ("");
2102
2103 WriteLine (td.FullTypeName + " dest = (" + td.FullTypeName + ") list;");
2104 WriteLine ("foreach (object ob in (IEnumerable)source)");
2105 WriteLine ("\tdest.Add (" + GetCast (td.ListItemTypeData, "ob") + ");");
2106 WriteLineUni ("}");
2107 WriteLine ("");
2108 }
2109 }
2110
2111 void GenerateReadXmlNodeElement (XmlTypeMapping typeMap, string isNullable)
2112 {
2113 WriteLine ("return " + GetReadXmlNode (typeMap.TypeData, false) + ";");
2114 }
2115
2116 void GenerateReadPrimitiveElement (XmlTypeMapping typeMap, string isNullable)
2117 {
2118 WriteLine ("XmlQualifiedName t = GetXsiType();");
2119 WriteLine ("if (t == null) t = new XmlQualifiedName (" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.Namespace) + ");");
2120 WriteLine ("return " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
2121 }
2122
2123 void GenerateReadEnumElement (XmlTypeMapping typeMap, string isNullable)
2124 {
2125 WriteLine ("Reader.ReadStartElement ();");
2126 WriteLine (typeMap.TypeFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
2127 WriteLine ("Reader.ReadEndElement ();");
2128 WriteLine ("return res;");
2129 }
2130
2131 string GenerateGetEnumValue (XmlTypeMapping typeMap, string val)
2132 {
2133 return GetGetEnumValueName (typeMap) + " (" + val + ")";
2134 }
2135
2136 void GenerateGetEnumValue (XmlTypeMapping typeMap)
2137 {
2138 string metName = GetGetEnumValueName (typeMap);
2139 EnumMap map = (EnumMap) typeMap.ObjectMap;
2140
2141 if (map.IsFlags)
2142 {
2143 string switchMethod = metName + "_Switch";
2144 WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2145 WriteLineInd ("{");
2146 WriteLine ("xmlName = xmlName.Trim();");
2147 WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeFullName + ")0;");
2148 WriteLine ("if (xmlName.IndexOf (' ') != -1)");
2149 WriteLineInd ("{");
2150 WriteLine (typeMap.TypeFullName + " sb = (" + typeMap.TypeFullName + ")0;");
2151 WriteLine ("string[] enumNames = xmlName.ToString().Split (' ');");
2152 WriteLine ("foreach (string name in enumNames)");
2153 WriteLineInd ("{");
2154 WriteLine ("if (name == string.Empty) continue;");
2155 WriteLine ("sb |= " + switchMethod + " (name); ");
2156 WriteLineUni ("}");
2157 WriteLine ("return sb;");
2158 WriteLineUni ("}");
2159 WriteLine ("else");
2160 WriteLine ("\treturn " + switchMethod + " (xmlName);");
2161 WriteLineUni ("}");
2162 metName = switchMethod;
2163 }
2164
2165 WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2166 WriteLineInd ("{");
2167 GenerateGetSingleEnumValue (typeMap, "xmlName");
2168 WriteLineUni ("}");
2169 WriteLine ("");
2170 }
2171
2172 void GenerateGetSingleEnumValue (XmlTypeMapping typeMap, string val)
2173 {
2174 EnumMap map = (EnumMap) typeMap.ObjectMap;
2175 WriteLine ("switch (" + val + ")");
2176 WriteLineInd ("{");
2177 foreach (EnumMap.EnumMapMember mem in map.Members)
2178 {
2179 WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeFullName + "." + mem.EnumName + ";");
2180 }
2181 WriteLineInd ("default:");
2182 WriteLineInd ("try {");
2183 WriteLine ("return (" + typeMap.TypeFullName + ") Int64.Parse (" + val + ", CultureInfo.InvariantCulture);");
2184 WriteLineUni ("}");
2185 WriteLineInd ("catch {");
2186 WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeFullName + "));");
2187 WriteLineUni ("}");
2188 Unindent ();
2189 WriteLineUni ("}");
2190 }
2191
2192 void GenerateReadXmlSerializableElement (XmlTypeMapping typeMap, string isNullable)
2193 {
2194 WriteLine ("Reader.MoveToContent ();");
2195 WriteLine ("if (Reader.NodeType == XmlNodeType.Element)");
2196 WriteLineInd ("{");
2197 WriteLine ("if (Reader.LocalName == " + GetLiteral (typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
2198 WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.FullTypeName + "());");
2199 WriteLine ("else");
2200 WriteLine ("\tthrow CreateUnknownNodeException ();");
2201 WriteLineUni ("}");
2202 WriteLine ("else UnknownNode (null);");
2203 WriteLine ("");
2204 WriteLine ("return null;");
2205 }
2206
2207 void GenerateReadInitCallbacks ()
2208 {
2209 WriteLine ("protected override void InitCallbacks ()");
2210 WriteLineInd ("{");
2211
2212 if (_format == SerializationFormat.Encoded)
2213 {
2214 foreach (XmlMapping xmap in _mapsToGenerate)
2215 {
2216 XmlTypeMapping map = xmap as XmlTypeMapping;
2217 if (map == null) continue;
2218 if (map.TypeData.SchemaType == SchemaTypes.Class || map.TypeData.SchemaType == SchemaTypes.Enum)
2219 WriteMetCall ("AddReadCallback", GetLiteral (map.XmlType), GetLiteral(map.Namespace), GetTypeOf(map.TypeData.Type), "new XmlSerializationReadCallback (" + GetReadObjectName (map) + ")");
2220 }
2221 }
2222
2223 WriteLineUni ("}");
2224 WriteLine ("");
2225
2226 WriteLine ("protected override void InitIDs ()");
2227 WriteLine ("{");
2228 WriteLine ("}");
2229 WriteLine ("");
2230 }
2231
2232 void GenerateFixupCallbacks ()
2233 {
2234 foreach (XmlMapping map in _fixupCallbacks)
2235 {
2236 bool isList = map is XmlMembersMapping;
2237 string tname = !isList ? ((XmlTypeMapping)map).TypeFullName : "object[]";
2238 WriteLine ("void " + GetFixupCallbackName (map) + " (object obfixup)");
2239 WriteLineInd ("{");
2240 WriteLine ("Fixup fixup = (Fixup)obfixup;");
2241 WriteLine (tname + " source = (" + tname + ") fixup.Source;");
2242 WriteLine ("string[] ids = fixup.Ids;");
2243 WriteLine ("");
2244
2245 ClassMap cmap = (ClassMap)map.ObjectMap;
2246 ICollection members = cmap.ElementMembers;
2247 if (members != null) {
2248 foreach (XmlTypeMapMember member in members)
2249 {
2250 WriteLineInd ("if (ids[" + member.Index + "] != null)");
2251 GenerateSetMemberValue (member, "source", GetCast (member.TypeData, "GetTarget(ids[" + member.Index + "])"), isList);
2252 Unindent ();
2253 }
2254 }
2255 WriteLineUni ("}");
2256 WriteLine ("");
2257 }
2258 }
2259
2260 string GetReadXmlNode (TypeData type, bool wrapped)
2261 {
2262 if (type.Type == typeof (XmlDocument))
2263 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlDocument)), "ReadXmlDocument (" + GetLiteral(wrapped) + ")");
2264 else
2265 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlNode)), "ReadXmlNode (" + GetLiteral(wrapped) + ")");
2266 }
2267
2268 #endregion
2269
2270 #region Helper methods
2271
2272 //*******************************************************
2273 // Helper methods
2274 //
2275
2276 ArrayList _listsToFill = new ArrayList ();
2277 Hashtable _hooks;
2278 Hashtable _hookVariables;
2279 Stack _hookContexts;
2280 Stack _hookOpenHooks;
2281
2282 class HookInfo {
2283 public HookType HookType;
2284 public Type Type;
2285 public string Member;
2286 public HookDir Direction;
2287 }
2288
2289 void InitHooks ()
2290 {
2291 _hookContexts = new Stack ();
2292 _hookOpenHooks = new Stack ();
2293 _hookVariables = new Hashtable ();
2294 _hooks = new Hashtable ();
2295 }
2296
2297 void PushHookContext ()
2298 {
2299 _hookContexts.Push (_hookVariables);
2300 _hookVariables = (Hashtable) _hookVariables.Clone ();
2301 }
2302
2303 void PopHookContext ()
2304 {
2305 _hookVariables = (Hashtable) _hookContexts.Pop ();
2306 }
2307
2308 void SetHookVar (string var, string value)
2309 {
2310 _hookVariables [var] = value;
2311 }
2312
2313 bool GenerateReadHook (HookType hookType, Type type)
2314 {
2315 return GenerateHook (hookType, HookDir.Read, type, null);
2316 }
2317
2318 bool GenerateWriteHook (HookType hookType, Type type)
2319 {
2320 return GenerateHook (hookType, HookDir.Write, type, null);
2321 }
2322
2323 bool GenerateWriteMemberHook (Type type, XmlTypeMapMember member)
2324 {
2325 SetHookVar ("$MEMBER", member.Name);
2326 return GenerateHook (HookType.member, HookDir.Write, type, member.Name);
2327 }
2328
2329 bool GenerateReadMemberHook (Type type, XmlTypeMapMember member)
2330 {
2331 SetHookVar ("$MEMBER", member.Name);
2332 return GenerateHook (HookType.member, HookDir.Read, type, member.Name);
2333 }
2334
2335 bool GenerateReadArrayMemberHook (Type type, XmlTypeMapMember member, string index)
2336 {
2337 SetHookVar ("$INDEX", index);
2338 return GenerateReadMemberHook (type, member);
2339 }
2340
2341 bool MemberHasReadReplaceHook (Type type, XmlTypeMapMember member)
2342 {
2343 if (_config == null) return false;
2344 return _config.GetHooks (HookType.member, HookDir.Read, HookAction.Replace, type, member.Name).Count > 0;
2345 }
2346
2347 bool GenerateHook (HookType hookType, HookDir dir, Type type, string member)
2348 {
2349 GenerateHooks (hookType, dir, type, null, HookAction.InsertBefore);
2350 if (GenerateHooks (hookType, dir, type, null, HookAction.Replace))
2351 {
2352 GenerateHooks (hookType, dir, type, null, HookAction.InsertAfter);
2353 return true;
2354 }
2355 else
2356 {
2357 HookInfo hi = new HookInfo ();
2358 hi.HookType = hookType;
2359 hi.Type = type;
2360 hi.Member = member;
2361 hi.Direction = dir;
2362 _hookOpenHooks.Push (hi);
2363 return false;
2364 }
2365 }
2366
2367 void GenerateEndHook ()
2368 {
2369 HookInfo hi = (HookInfo) _hookOpenHooks.Pop();
2370 GenerateHooks (hi.HookType, hi.Direction, hi.Type, hi.Member, HookAction.InsertAfter);
2371 }
2372
2373 bool GenerateHooks (HookType hookType, HookDir dir, Type type, string member, HookAction action)
2374 {
2375 if (_config == null) return false;
2376 ArrayList hooks = _config.GetHooks (hookType, dir, action, type, null);
2377 if (hooks.Count == 0) return false;
2378 foreach (Hook hook in hooks)
2379 {
2380 string code = hook.GetCode (action);
2381 foreach (DictionaryEntry de in _hookVariables)
2382 code = code.Replace ((string)de.Key, (string)de.Value);
2383 WriteMultilineCode (code);
2384 }
2385 return true;
2386 }
2387
2388 string GetRootTypeName ()
2389 {
2390 if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeFullName;
2391 else return "object[]";
2392 }
2393
2394 string GetNumTempVar ()
2395 {
2396 return "n" + (_tempVarId++);
2397 }
2398
2399 string GetObTempVar ()
2400 {
2401 return "o" + (_tempVarId++);
2402 }
2403
2404 string GetStrTempVar ()
2405 {
2406 return "s" + (_tempVarId++);
2407 }
2408
2409 string GetBoolTempVar ()
2410 {
2411 return "b" + (_tempVarId++);
2412 }
2413
2414 string GetUniqueName (string uniqueGroup, object ob, string name)
2415 {
2416 name = name.Replace ("[]","_array");
2417 Hashtable names = (Hashtable) _uniqueNames [uniqueGroup];
2418 if (names == null) {
2419 names = new Hashtable ();
2420 _uniqueNames [uniqueGroup] = names;
2421 }
2422
2423 string res = (string) names [ob];
2424 if (res != null) return res;
2425
2426 foreach (string n in names.Values)
2427 if (n == name) return GetUniqueName (uniqueGroup, ob, name + (_methodId++));
2428
2429 names [ob] = name;
2430 return name;
2431 }
2432
2433 void RegisterReferencingMap (XmlTypeMapping typeMap)
2434 {
2435 if (typeMap != null && !_mapsToGenerate.Contains (typeMap))
2436 _mapsToGenerate.Add (typeMap);
2437 }
2438
2439 string GetWriteObjectName (XmlTypeMapping typeMap)
2440 {
2441 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2442 return GetUniqueName ("rw", typeMap, "WriteObject_" + typeMap.XmlType);
2443 }
2444
2445 string GetReadObjectName (XmlTypeMapping typeMap)
2446 {
2447 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2448 return GetUniqueName ("rr", typeMap, "ReadObject_" + typeMap.XmlType);
2449 }
2450
2451 string GetGetEnumValueName (XmlTypeMapping typeMap)
2452 {
2453 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2454 return GetUniqueName ("ge", typeMap, "GetEnumValue_" + typeMap.XmlType);
2455 }
2456
2457 string GetWriteObjectCallbackName (XmlTypeMapping typeMap)
2458 {
2459 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2460 return GetUniqueName ("wc", typeMap, "WriteCallback_" + typeMap.XmlType);
2461 }
2462
2463 string GetFixupCallbackName (XmlMapping typeMap)
2464 {
2465 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2466
2467 if (typeMap is XmlTypeMapping)
2468 return GetUniqueName ("fc", typeMap, "FixupCallback_" + ((XmlTypeMapping)typeMap).XmlType);
2469 else
2470 return GetUniqueName ("fc", typeMap, "FixupCallback__Message");
2471 }
2472
2473 string GetUniqueClassName (string s)
2474 {
2475 return classNames.AddUnique (s, null);
2476 }
2477
2478 string GetReadObjectCall (XmlTypeMapping typeMap, string isNullable, string checkType)
2479 {
2480 if (_format == SerializationFormat.Literal)
2481 return GetReadObjectName (typeMap) + " (" + isNullable + ", " + checkType + ")";
2482 else
2483 return GetCast (typeMap.TypeData, GetReadObjectName (typeMap) + " ()");
2484 }
2485
2486 string GetFillListName (TypeData td)
2487 {
2488 if (!_listsToFill.Contains (td)) _listsToFill.Add (td);
2489 return GetUniqueName ("fl", td, "Fill_" + td.TypeName);
2490 }
2491
2492 string GetCast (TypeData td, TypeData tdval, string val)
2493 {
2494 if (td.FullTypeName == tdval.FullTypeName) return val;
2495 else return GetCast (td, val);
2496 }
2497
2498 string GetCast (TypeData td, string val)
2499 {
2500 return "((" + td.FullTypeName + ") " + val + ")";
2501 }
2502
2503 string GetCast (Type td, string val)
2504 {
2505 return "((" + td.FullName + ") " + val + ")";
2506 }
2507
2508 string GetTypeOf (TypeData td)
2509 {
2510 return "typeof(" + td.FullTypeName + ")";
2511 }
2512
2513 string GetTypeOf (Type td)
2514 {
2515 return "typeof(" + td.FullName + ")";
2516 }
2517
2518 string GetString (string str)
2519 {
2520 return "\"" + str + "\"";
2521 }
2522
2523 string GetLiteral (object ob)
2524 {
2525 if (ob == null) return "null";
2526 if (ob is string) return "\"" + ob.ToString().Replace("\"","\"\"") + "\"";
2527 if (ob is bool) return ((bool)ob) ? "true" : "false";
2528 if (ob is XmlQualifiedName) {
2529 XmlQualifiedName qn = (XmlQualifiedName)ob;
2530 return "new XmlQualifiedName (" + GetLiteral(qn.Name) + "," + GetLiteral(qn.Namespace) + ")";
2531 }
2532 else return (ob is IFormattable) ? ((IFormattable) ob).ToString (null, CultureInfo.InvariantCulture) : ob.ToString ();
2533 }
2534
2535 void WriteLineInd (string code)
2536 {
2537 WriteLine (code);
2538 _indent++;
2539 }
2540
2541 void WriteLineUni (string code)
2542 {
2543 if (_indent > 0) _indent--;
2544 WriteLine (code);
2545 }
2546
2547 void WriteLine (string code)
2548 {
2549 if (code != "") _writer.Write (new String ('\t',_indent));
2550 _writer.WriteLine (code);
2551 }
2552
2553 void WriteMultilineCode (string code)
2554 {
2555 string tabs = new string ('\t',_indent);
2556 code = code.Replace ("\r","");
2557 code = code.Replace ("\t","");
2558 while (code.StartsWith ("\n")) code = code.Substring (1);
2559 while (code.EndsWith ("\n")) code = code.Substring (0, code.Length - 1);
2560 code = code.Replace ("\n", "\n" + tabs);
2561 WriteLine (code);
2562 }
2563
2564 string Params (params string[] pars)
2565 {
2566 string res = "";
2567 foreach (string p in pars)
2568 {
2569 if (res != "") res += ", ";
2570 res += p;
2571 }
2572 return res;
2573 }
2574
2575 void WriteMetCall (string method, params string[] pars)
2576 {
2577 WriteLine (method + " (" + Params (pars) + ");");
2578 }
2579
2580 void Indent ()
2581 {
2582 _indent++;
2583 }
2584
2585 void Unindent ()
2586 {
2587 _indent--;
2588 }
2589
2590 #endregion
2591
2592 }
2593
2594 internal class GenerationResult
2595 {
2596 public XmlMapping Mapping;
2597 public string ReaderClassName;
2598 public string ReadMethodName;
2599 public string WriterClassName;
2600 public string WriteMethodName;
2601 public string Namespace;
2602 public string SerializerClassName;
2603 }
2604
2605 }
Mirror of the official Mono project git repository