2 // System.Xml.Serialization.SerializationCodeGenerator.cs:
5 // Lluis Sanchez Gual (lluis@ximian.com)
7 // (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
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:
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
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.
32 using System.Reflection;
33 using System.Xml.Serialization;
34 using System.Collections;
35 using System.Globalization;
37 namespace System.Xml.Serialization
39 internal class SerializationCodeGenerator
42 SerializationFormat _format;
46 Hashtable _uniqueNames = new Hashtable();
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;
56 CodeIdentifiers classNames = new CodeIdentifiers ();
58 public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
62 public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
68 public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
70 _xmlMaps = new XmlMapping [] {xmlMap};
74 public static void Generate (string configFileName, string outputPath)
76 SerializationCodeGeneratorConfiguration cnf = null;
77 StreamReader sr = new StreamReader (configFileName);
80 XmlReflectionImporter ri = new XmlReflectionImporter ();
81 ri.AllowPrivateTypes = true;
82 XmlSerializer ser = new XmlSerializer (ri.ImportTypeMapping (typeof (SerializationCodeGeneratorConfiguration)));
83 cnf = (SerializationCodeGeneratorConfiguration) ser.Deserialize (sr);
90 if (outputPath == null) outputPath = "";
92 CodeIdentifiers ids = new CodeIdentifiers ();
93 if (cnf.Serializers != null)
95 foreach (SerializerInfo info in cnf.Serializers)
98 if (info.Assembly != null)
102 asm = Assembly.Load (info.Assembly);
104 asm = Assembly.LoadFrom (info.Assembly);
106 type = asm.GetType (info.ClassName, true);
109 type = Type.GetType (info.ClassName);
111 if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
113 string file = info.OutFileName;
114 if (file == null || file.Length == 0) {
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";
120 StreamWriter writer = new StreamWriter (Path.Combine (outputPath, file));
126 if (info.SerializationFormat == SerializationFormat.Literal) {
127 XmlReflectionImporter ri = new XmlReflectionImporter ();
128 map = ri.ImportTypeMapping (type);
131 SoapReflectionImporter ri = new SoapReflectionImporter ();
132 map = ri.ImportTypeMapping (type);
135 SerializationCodeGenerator gen = new SerializationCodeGenerator (map, info);
136 gen.GenerateSerializers (writer);
146 public void GenerateSerializers (TextWriter writer)
149 _results = new GenerationResult [_xmlMaps.Length];
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 + ";");
164 string readerClassName = null;
165 string writerClassName = null;
166 string namspace = null;
170 readerClassName = _config.ReaderClassName;
171 writerClassName = _config.WriterClassName;
172 namspace = _config.Namespace;
175 if (readerClassName == null || readerClassName.Length == 0)
176 readerClassName = "GeneratedReader";
178 if (writerClassName == null || writerClassName.Length == 0)
179 writerClassName = "GeneratedWriter";
181 readerClassName = GetUniqueClassName (readerClassName);
182 writerClassName = GetUniqueClassName (writerClassName);
184 Hashtable mapsByNamespace = new Hashtable ();
185 Hashtable generatedMaps = new Hashtable ();
187 for (int n=0; n<_xmlMaps.Length; n++)
189 _typeMap = _xmlMaps [n];
190 if (_typeMap == null) continue;
192 _result = generatedMaps [_typeMap] as GenerationResult;
193 if (_result != null) {
194 _results[n] = _result;
198 _result = new GenerationResult ();
199 _results[n] = _result;
201 generatedMaps [_typeMap] = _result;
204 if (_typeMap is XmlTypeMapping) typeName = ((XmlTypeMapping)_typeMap).TypeName;
205 else typeName = ((XmlMembersMapping)_typeMap).ElementName;
207 _result.ReaderClassName = readerClassName;
208 _result.WriterClassName = writerClassName;
210 if (namspace == null || namspace.Length == 0)
211 _result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
213 _result.Namespace = namspace;
215 _result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
216 _result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
218 _result.Mapping = _typeMap;
220 ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
222 maps = new ArrayList ();
223 mapsByNamespace [_result.Namespace] = maps;
228 foreach (DictionaryEntry entry in mapsByNamespace)
230 ArrayList maps = (ArrayList) entry.Value;
232 WriteLine ("namespace " + entry.Key);
235 if (_config == null || !_config.NoReader)
236 GenerateReader (readerClassName, maps);
238 if (_config == null || !_config.NoWriter)
239 GenerateWriter (writerClassName, maps);
243 GenerateContract (maps);
251 public GenerationResult[] GenerationResults
253 get { return _results; }
256 public ArrayList ReferencedTypes
258 get { return _referencedTypes; }
261 void UpdateGeneratedTypes (ArrayList list)
263 for (int n=0; n<list.Count; n++)
265 XmlTypeMapping map = list[n] as XmlTypeMapping;
266 if (map != null && !_referencedTypes.Contains (map.TypeData.Type))
267 _referencedTypes.Add (map.TypeData.Type);
271 #region Writer Generation
273 //*******************************************************
274 // Contract generation
278 public void GenerateContract (ArrayList generatedMaps)
280 // Write the base serializer
282 if (generatedMaps.Count == 0) return;
284 GenerationResult main = (GenerationResult) generatedMaps[0];
286 string baseSerializerName = GetUniqueClassName ("BaseXmlSerializer");
289 WriteLine ("public class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
291 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
292 WriteLine ("return new " + main.ReaderClassName + " ();");
296 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {");
297 WriteLine ("return new " + main.WriterClassName + " ();");
301 WriteLineInd ("public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {");
302 WriteLine ("return true;");
308 // Write a serializer for each imported map
310 foreach (GenerationResult res in generatedMaps)
312 res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
314 WriteLine ("public sealed class " + res.SerializerClassName + " : " + baseSerializerName);
316 WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
317 WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
321 WriteLineInd ("protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {");
322 WriteLine ("return ((" + res.ReaderClassName + ")reader)." + res.ReadMethodName + "();");
329 WriteLine ("public class XmlSerializerContract : System.Xml.Serialization.IXmlSerializerImplementation");
332 WriteLine ("System.Collections.Hashtable readMethods = null;");
333 WriteLine ("System.Collections.Hashtable writeMethods = null;");
334 WriteLine ("System.Collections.Hashtable typedSerializers = null;");
337 WriteLineInd ("public System.Xml.Serialization.XmlSerializationReader Reader {");
338 WriteLineInd ("get {");
339 WriteLine ("return new " + main.ReaderClassName + "();");
344 WriteLineInd ("public System.Xml.Serialization.XmlSerializationWriter Writer {");
345 WriteLineInd ("get {");
346 WriteLine ("return new " + main.WriterClassName + "();");
351 WriteLineInd ("public System.Collections.Hashtable ReadMethods {");
352 WriteLineInd ("get {");
353 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
354 WriteLineInd ("if (readMethods == null) {");
355 WriteLine ("readMethods = new System.Collections.Hashtable ();");
356 foreach (GenerationResult res in generatedMaps)
357 WriteLine ("readMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.ReadMethodName + "\");");
359 WriteLine ("return readMethods;");
365 WriteLineInd ("public System.Collections.Hashtable WriteMethods {");
366 WriteLineInd ("get {");
367 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
368 WriteLineInd ("if (writeMethods == null) {");
369 WriteLine ("writeMethods = new System.Collections.Hashtable ();");
370 foreach (GenerationResult res in generatedMaps)
371 WriteLine ("writeMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.WriteMethodName + "\");");
373 WriteLine ("return writeMethods;");
379 WriteLineInd ("public System.Collections.Hashtable TypedSerializers {");
380 WriteLineInd ("get {");
381 WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
382 WriteLineInd ("if (typedSerializers == null) {");
383 WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
384 foreach (GenerationResult res in generatedMaps)
385 WriteLine ("typedSerializers.Add (@\"" + res.Mapping.GetKey () + "\", new " + res.SerializerClassName + "());");
387 WriteLine ("return typedSerializers;");
392 WriteLineInd ("public bool CanSerialize (System.Type type) {");
393 foreach (GenerationResult res in generatedMaps) {
394 if (res.Mapping is XmlTypeMapping)
395 WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.FullTypeName + ")) return true;");
397 WriteLine ("return false;");
406 //*******************************************************
410 public void GenerateWriter (string writerClassName, ArrayList maps)
412 _mapsToGenerate = new ArrayList ();
416 if (_config == null || !_config.GenerateAsInternal)
417 WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
419 WriteLine ("internal class " + writerClassName + " : XmlSerializationWriter");
421 WriteLine ("const string xmlNamespace = \"http://www.w3.org/2000/xmlns/\";");
423 for (int n=0; n<maps.Count; n++)
425 GenerationResult res = (GenerationResult) maps [n];
426 _typeMap = res.Mapping;
427 _format = _typeMap.Format;
430 GenerateWriteRoot ();
433 for (int n=0; n<_mapsToGenerate.Count; n++)
435 XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
436 GenerateWriteObject (map);
437 if (map.TypeData.SchemaType == SchemaTypes.Enum)
438 GenerateGetXmlEnumValue (map);
441 GenerateWriteInitCallbacks ();
442 UpdateGeneratedTypes (_mapsToGenerate);
447 void GenerateWriteRoot ()
449 WriteLine ("public void " +_result.WriteMethodName + " (object o)");
451 WriteLine ("WriteStartDocument ();");
453 if (_typeMap is XmlTypeMapping)
455 WriteLine (GetRootTypeName () + " ob = (" + GetRootTypeName () + ") o;");
456 XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
457 if (mp.TypeData.SchemaType == SchemaTypes.Class || mp.TypeData.SchemaType == SchemaTypes.Array)
458 WriteLine ("TopLevelElement ();");
460 if (_format == SerializationFormat.Literal) {
461 WriteLine (GetWriteObjectName (mp) + " (ob, " + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", true, false, true);");
464 RegisterReferencingMap (mp);
465 WriteLine ("WritePotentiallyReferencingElement (" + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", ob, " + GetTypeOf(mp.TypeData) + ", true, false);");
468 else if (_typeMap is XmlMembersMapping) {
469 WriteLine ("object[] pars = (object[]) o;");
470 GenerateWriteMessage ((XmlMembersMapping) _typeMap);
473 throw new InvalidOperationException ("Unknown type map");
475 if (_format == SerializationFormat.Encoded)
476 WriteLine ("WriteReferencedElements ();");
482 void GenerateWriteMessage (XmlMembersMapping membersMap)
484 if (membersMap.HasWrapperElement) {
485 WriteLine ("TopLevelElement ();");
486 WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));");
488 /* WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)");
489 WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);");
492 WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)");
493 WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);");
498 GenerateWriteObjectElement (membersMap, "pars", true);
500 if (membersMap.HasWrapperElement)
501 WriteLine ("WriteEndElement();");
504 void GenerateGetXmlEnumValue (XmlTypeMapping map)
506 EnumMap emap = (EnumMap) map.ObjectMap;
508 string xmlNamesArray = null;
509 string valuesArray = null;
512 // create static string[] holding XML names of enum constants
513 xmlNamesArray = GetUniqueName ("gxe", map, "_xmlNames" + map.XmlType);
514 Write ("static readonly string[] " + xmlNamesArray + " = { ");
515 for (int i = 0; i < emap.XmlNames.Length; i++) {
519 _writer.Write (emap.XmlNames[i]);
520 _writer.Write ('\"');
522 _writer.WriteLine (" };");
524 // create const long[] holding values of enum constants
525 valuesArray = GetUniqueName ("gve", map, "_values" + map.XmlType);
526 Write ("static readonly long[] " + valuesArray + " = { ");
527 for (int i = 0; i < emap.Values.Length; i++) {
530 _writer.Write (emap.Values[i].ToString (CultureInfo.InvariantCulture));
533 _writer.WriteLine (" };");
534 WriteLine (string.Empty);
537 WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeFullName + " val)");
541 WriteLineInd ("switch (val) {");
542 for (int i = 0; i < emap.EnumNames.Length; i++)
543 WriteLine ("case " + map.TypeFullName + "." + emap.EnumNames[i] + ": return " + GetLiteral (emap.XmlNames[i]) + ";");
546 WriteLineInd ("default:");
547 // FromEnum actually covers this case too, but we save some cycles here
548 WriteLine ("if (val.ToString () == \"0\") return string.Empty;");
549 Write ("return FromEnum ((long) val, " + xmlNamesArray + ", " + valuesArray);
551 _writer.Write (", typeof (");
552 _writer.Write (map.TypeFullName);
553 _writer.Write (").FullName");
555 _writer.Write (')'); // close FromEnum method call
556 WriteUni (";"); // end statement
559 WriteLine ("default: throw CreateInvalidEnumValueException ((long) val, typeof (" + map.TypeFullName + ").FullName);");
561 WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
571 void GenerateWriteObject (XmlTypeMapping typeMap)
573 WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
578 SetHookVar ("$TYPE", typeMap.TypeName);
579 SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
580 SetHookVar ("$OBJECT", "ob");
581 SetHookVar ("$ELEMENT", "element");
582 SetHookVar ("$NAMESPACE", "namesp");
583 SetHookVar ("$NULLABLE", "isNullable");
585 if (GenerateWriteHook (HookType.type, typeMap.TypeData.Type))
593 if (!typeMap.TypeData.IsValueType)
595 WriteLine ("if (((object)ob) == null)");
597 WriteLineInd ("if (isNullable)");
599 if (_format == SerializationFormat.Literal)
600 WriteLine ("WriteNullTagLiteral(element, namesp);");
602 WriteLine ("WriteNullTagEncoded (element, namesp);");
604 WriteLineUni ("return;");
609 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
611 if (_format == SerializationFormat.Literal)
612 WriteLine ("WriteElementLiteral (ob, \"\", \"\", true, false);");
614 WriteLine ("WriteElementEncoded (ob, \"\", \"\", true, false);");
623 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlSerializable)
625 WriteLine ("WriteSerializable (ob, element, namesp, isNullable);");
634 ArrayList types = typeMap.DerivedTypes;
636 WriteLine ("System.Type type = ob.GetType ();");
637 WriteLine ("if (type == typeof(" + typeMap.TypeFullName + "))");
640 for (int n=0; n<types.Count; n++)
642 XmlTypeMapping map = (XmlTypeMapping)types[n];
644 WriteLineInd ("else if (type == typeof(" + map.TypeFullName + ")) { ");
645 WriteLine (GetWriteObjectName (map) + "((" + map.TypeFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
646 WriteLine ("return;");
650 if (typeMap.TypeData.Type == typeof (object)) {
651 WriteLineInd ("else {");
652 WriteLine ("WriteTypedPrimitive (element, namesp, ob, true);");
653 WriteLine ("return;");
658 WriteLineInd ("else {");
659 WriteLine ("throw CreateUnknownTypeException (ob);");
663 WriteLineInd ("if (writeWrappingElem) {");
664 if (_format == SerializationFormat.Encoded) WriteLine ("needType = true;");
665 WriteLine ("WriteStartElement (element, namesp, ob);");
669 WriteLine ("if (needType) WriteXsiType(" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.XmlTypeNamespace) + ");");
672 switch (typeMap.TypeData.SchemaType)
674 case SchemaTypes.Class: GenerateWriteObjectElement (typeMap, "ob", false); break;
675 case SchemaTypes.Array: GenerateWriteListElement (typeMap, "ob"); break;
676 case SchemaTypes.Primitive: GenerateWritePrimitiveElement (typeMap, "ob"); break;
677 case SchemaTypes.Enum: GenerateWriteEnumElement (typeMap, "ob"); break;
680 WriteLine ("if (writeWrappingElem) WriteEndElement (ob);");
689 void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
691 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
692 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
694 ClassMap map = (ClassMap)xmlMap.ObjectMap;
695 if (!GenerateWriteHook (HookType.attributes, xmlMapType))
697 if (map.NamespaceDeclarations != null) {
698 WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
702 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
703 if (anyAttrMember != null)
705 if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
707 string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
708 if (cond != null) WriteLineInd ("if (" + cond + ") {");
710 string tmpVar = GetObTempVar ();
711 WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
712 WriteLineInd ("if (" + tmpVar + " != null) {");
714 string tmpVar2 = GetObTempVar ();
715 WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
716 WriteLineInd ("if (" + tmpVar2 + ".NamespaceURI != xmlNamespace)");
717 WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
722 if (cond != null) WriteLineUni ("}");
728 ICollection attributes = map.AttributeMembers;
729 if (attributes != null)
731 foreach (XmlTypeMapMemberAttribute attr in attributes)
733 if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
735 string val = GenerateGetMemberValue (attr, ob, isValueList);
736 string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
738 if (cond != null) WriteLineInd ("if (" + cond + ") {");
740 string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val);
741 WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
743 if (cond != null) WriteLineUni ("}");
751 if (!GenerateWriteHook (HookType.elements, xmlMapType))
753 ICollection members = map.ElementMembers;
756 foreach (XmlTypeMapMemberElement member in members)
758 if (GenerateWriteMemberHook (xmlMapType, member)) continue;
760 string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
761 if (cond != null) WriteLineInd ("if (" + cond + ") {");
763 string memberValue = GenerateGetMemberValue (member, ob, isValueList);
764 Type memType = member.GetType();
766 if (memType == typeof(XmlTypeMapMemberList))
768 GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
770 else if (memType == typeof(XmlTypeMapMemberFlatList))
772 WriteLineInd ("if (" + memberValue + " != null) {");
773 GenerateWriteListContent (ob, member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
776 else if (memType == typeof(XmlTypeMapMemberAnyElement))
778 WriteLineInd ("if (" + memberValue + " != null) {");
779 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
782 else if (memType == typeof(XmlTypeMapMemberAnyElement))
784 WriteLineInd ("if (" + memberValue + " != null) {");
785 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
788 else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
792 else if (memType == typeof(XmlTypeMapMemberElement))
794 if (member.ElementInfo.Count == 1) {
795 GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
797 else if (member.ChoiceMember != null)
799 string choiceValue = ob + ".@" + member.ChoiceMember;
800 foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
801 WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
802 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
808 // WriteLineInd ("if (" + memberValue + " == null) {");
809 // GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
810 // WriteLineUni ("}");
813 foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
815 WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.FullTypeName + ") {");
816 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
823 throw new InvalidOperationException ("Unknown member type");
835 void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
837 switch (elem.TypeData.SchemaType)
839 case SchemaTypes.XmlNode:
840 string elemName = elem.WrappedElement ? elem.ElementName : "";
841 if (_format == SerializationFormat.Literal)
842 WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
844 WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
847 case SchemaTypes.Enum:
848 case SchemaTypes.Primitive:
849 if (_format == SerializationFormat.Literal)
850 GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
852 GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
855 case SchemaTypes.Array:
856 WriteLineInd ("if (" + memberValue + " != null) {");
858 if (elem.MappedType.MultiReferenceType) {
859 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
860 RegisterReferencingMap (elem.MappedType);
863 WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
864 GenerateWriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
865 WriteMetCall ("WriteEndElement", memberValue);
869 if (elem.IsNullable) {
870 WriteLineInd ("else");
871 if (_format == SerializationFormat.Literal)
872 WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
874 WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
880 case SchemaTypes.Class:
881 if (elem.MappedType.MultiReferenceType) {
882 RegisterReferencingMap (elem.MappedType);
883 if (elem.MappedType.TypeData.Type == typeof(object))
884 WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
886 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
889 WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
892 case SchemaTypes.XmlSerializable:
893 WriteMetCall ("WriteSerializable", memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
897 throw new NotSupportedException ("Invalid value type");
901 void GenerateWriteListElement (XmlTypeMapping typeMap, string ob)
903 if (_format == SerializationFormat.Encoded)
906 string itemCount = GenerateGetListCount (typeMap.TypeData, ob);
907 GenerateGetArrayType ((ListMap) typeMap.ObjectMap, itemCount, out n, out ns);
910 if (ns != string.Empty)
911 arrayType = "FromXmlQualifiedName (new XmlQualifiedName(" + n + "," + ns + "))";
913 arrayType = GetLiteral (n);
915 WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
917 GenerateWriteListContent (null, typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
920 void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
922 bool singleElement = (member.TypeData.Type == typeof (XmlElement));
928 var = GetObTempVar ();
929 WriteLineInd ("foreach (XmlNode " + var + " in " + memberValue + ") {");
932 string elem = GetObTempVar ();
933 WriteLine ("XmlNode " + elem + " = " + var + ";");
934 WriteLine ("if (" + elem + " is XmlElement) {");
936 if (!member.IsDefaultAny) {
937 for (int n=0; n<member.ElementInfo.Count; n++) {
938 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)member.ElementInfo[n];
939 string txt = "(" + elem + ".Name == " + GetLiteral(info.ElementName) + " && " + elem + ".NamespaceURI == " + GetLiteral(info.Namespace) + ")";
940 if (n == member.ElementInfo.Count-1) txt += ") {";
941 if (n == 0) WriteLineInd ("if (" + txt);
942 else WriteLine ("|| " + txt);
946 WriteLine ("else " + elem + ".WriteTo (Writer);");
948 if (_format == SerializationFormat.Literal)
949 WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
951 WriteLine ("WriteElementEncoded (" + elem + ", \"\", \"\", false, true);");
953 if (!member.IsDefaultAny) {
955 WriteLineInd ("else");
956 WriteLine ("throw CreateUnknownAnyElementException (" + elem + ".Name, " + elem + ".NamespaceURI);");
964 void GenerateWritePrimitiveElement (XmlTypeMapping typeMap, string ob)
966 string strVal = GenerateGetStringValue (typeMap, typeMap.TypeData, ob);
967 WriteLine ("Writer.WriteString (" + strVal + ");");
970 void GenerateWriteEnumElement (XmlTypeMapping typeMap, string ob)
972 string strVal = GenerateGetEnumXmlValue (typeMap, ob);
973 WriteLine ("Writer.WriteString (" + strVal + ");");
976 string GenerateGetStringValue (XmlTypeMapping typeMap, TypeData type, string value)
978 if (type.SchemaType == SchemaTypes.Array) {
979 string str = GetStrTempVar ();
980 WriteLine ("string " + str + " = null;");
981 WriteLineInd ("if (" + value + " != null) {");
982 string res = GenerateWriteListContent (null, typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
983 WriteLine (str + " = " + res + ".ToString ().Trim ();");
987 else if (type.SchemaType == SchemaTypes.Enum) {
988 return GenerateGetEnumXmlValue (typeMap, value);
990 else if (type.Type == typeof (XmlQualifiedName))
991 return "FromXmlQualifiedName (" + value + ")";
992 else if (value == null)
995 return XmlCustomFormatter.GenerateToXmlString (type, value);
998 string GenerateGetEnumXmlValue (XmlTypeMapping typeMap, string ob)
1000 return GetGetEnumValueName (typeMap) + " (" + ob + ")";
1003 string GenerateGetListCount (TypeData listType, string ob)
1005 if (listType.Type.IsArray)
1011 void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns)
1014 if (itemCount != "") arrayDim = "";
1015 else arrayDim = "[]";
1017 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0];
1018 if (info.TypeData.SchemaType == SchemaTypes.Array)
1021 GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns);
1022 localName = nm + arrayDim;
1026 if (info.MappedType != null)
1028 localName = info.MappedType.XmlType + arrayDim;
1029 ns = info.MappedType.Namespace;
1033 localName = info.TypeData.XmlType + arrayDim;
1034 ns = info.DataTypeNamespace;
1037 if (itemCount != "") {
1038 localName = "\"" + localName + "[\" + " + itemCount + " + \"]\"";
1039 ns = GetLiteral (ns);
1043 string GenerateWriteListContent (string container, TypeData listType, ListMap map, string ob, bool writeToString)
1045 string targetString = null;
1049 targetString = GetStrTempVar ();
1050 WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();");
1053 if (listType.Type.IsArray)
1055 string itemVar = GetNumTempVar ();
1056 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
1057 GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
1060 else if (typeof(ICollection).IsAssignableFrom (listType.Type))
1062 string itemVar = GetNumTempVar ();
1063 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
1064 GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
1067 else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
1069 string itemVar = GetObTempVar ();
1070 WriteLineInd ("foreach (" + listType.ListItemTypeData.FullTypeName + " " + itemVar + " in " + ob + ") {");
1071 GenerateListLoop (container, map, itemVar, null, listType.ListItemTypeData, targetString);
1075 throw new Exception ("Unsupported collection type");
1077 return targetString;
1080 void GenerateListLoop (string container, ListMap map, string item, string index, TypeData itemTypeData, string targetString)
1082 bool multichoice = (map.ItemInfo.Count > 1);
1084 if (map.ChoiceMember != null && container != null && index != null) {
1085 WriteLineInd ("if ((" + container + ".@" + map.ChoiceMember + " == null) || (" + index + " >= " + container + ".@" + map.ChoiceMember + ".Length))");
1086 WriteLine ("throw CreateInvalidChoiceIdentifierValueException (" + container + ".GetType().ToString(), \"" + map.ChoiceMember + "\");");
1091 WriteLine ("if (((object)" + item + ") == null) { }");
1093 foreach (XmlTypeMapElementInfo info in map.ItemInfo)
1095 if (map.ChoiceMember != null && multichoice)
1096 WriteLineInd ("else if (" + container + ".@" + map.ChoiceMember + "[" + index + "] == " + GetLiteral (info.ChoiceValue) + ") {");
1097 else if (multichoice)
1098 WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.FullTypeName + ")) {");
1100 if (targetString == null)
1101 GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
1104 string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item));
1105 WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");");
1113 WriteLine ("else throw CreateUnknownTypeException (" + item + ");");
1116 void GenerateWritePrimitiveValueLiteral (string memberValue, string name, string ns, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1119 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1120 WriteMetCall ("WriteValue", strVal);
1122 else if (isNullable) {
1123 if (typeData.Type == typeof(XmlQualifiedName))
1124 WriteMetCall ("WriteNullableQualifiedNameLiteral", GetLiteral(name), GetLiteral(ns), memberValue);
1126 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1127 WriteMetCall ("WriteNullableStringLiteral", GetLiteral(name), GetLiteral(ns), strVal);
1131 if (typeData.Type == typeof(XmlQualifiedName))
1132 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue);
1134 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1135 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal);
1140 void GenerateWritePrimitiveValueEncoded (string memberValue, string name, string ns, XmlQualifiedName xsiType, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1143 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1144 WriteMetCall ("WriteValue", strVal);
1146 else if (isNullable) {
1147 if (typeData.Type == typeof(XmlQualifiedName))
1148 WriteMetCall ("WriteNullableQualifiedNameEncoded", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1150 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1151 WriteMetCall ("WriteNullableStringEncoded", GetLiteral(name), GetLiteral(ns), strVal, GetLiteral(xsiType));
1155 if (typeData.Type == typeof(XmlQualifiedName))
1156 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1158 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1159 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal, GetLiteral(xsiType));
1164 string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
1166 if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.GlobalIndex + "]");
1167 else return ob + ".@" + member.Name;
1170 string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
1173 return ob + ".Length > " + member.GlobalIndex;
1175 else if (member.DefaultValue != System.DBNull.Value) {
1176 string mem = ob + ".@" + member.Name;
1177 if (member.DefaultValue == null)
1178 return mem + " != null";
1179 else if (member.TypeData.SchemaType == SchemaTypes.Enum)
1180 return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
1182 return mem + " != " + GetLiteral (member.DefaultValue);
1184 else if (member.IsOptionalValueType)
1185 return ob + ".@" + member.Name + "Specified";
1189 void GenerateWriteInitCallbacks ()
1191 WriteLine ("protected override void InitCallbacks ()");
1194 if (_format == SerializationFormat.Encoded)
1196 foreach (XmlMapping xmap in _mapsToGenerate) {
1197 XmlTypeMapping map = xmap as XmlTypeMapping;
1199 WriteMetCall ("AddWriteCallback", GetTypeOf(map.TypeData), GetLiteral(map.XmlType), GetLiteral(map.Namespace), "new XmlSerializationWriteCallback (" + GetWriteObjectCallbackName (map) + ")");
1206 if (_format == SerializationFormat.Encoded)
1208 foreach (XmlTypeMapping xmap in _mapsToGenerate) {
1209 XmlTypeMapping map = xmap as XmlTypeMapping;
1210 if (map == null) continue;
1211 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1212 WriteWriteEnumCallback (map);
1214 WriteWriteObjectCallback (map);
1219 void WriteWriteEnumCallback (XmlTypeMapping map)
1221 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1223 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "true", "false");
1228 void WriteWriteObjectCallback (XmlTypeMapping map)
1230 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1232 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "false", "false");
1239 #region Reader Generation
1241 //*******************************************************
1242 // Reader generation
1245 public void GenerateReader (string readerClassName, ArrayList maps)
1247 if (_config == null || !_config.GenerateAsInternal)
1248 WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
1250 WriteLine ("internal class " + readerClassName + " : XmlSerializationReader");
1253 _mapsToGenerate = new ArrayList ();
1254 _fixupCallbacks = new ArrayList ();
1257 for (int n=0; n<maps.Count; n++)
1259 GenerationResult res = (GenerationResult) maps [n];
1260 _typeMap = res.Mapping;
1261 _format = _typeMap.Format;
1264 GenerateReadRoot ();
1267 for (int n=0; n<_mapsToGenerate.Count; n++)
1269 XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
1270 if (map == null) continue;
1272 GenerateReadObject (map);
1273 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1274 GenerateGetEnumValue (map);
1277 GenerateReadInitCallbacks ();
1279 if (_format == SerializationFormat.Encoded)
1281 GenerateFixupCallbacks ();
1282 GenerateFillerCallbacks ();
1286 UpdateGeneratedTypes (_mapsToGenerate);
1289 void GenerateReadRoot ()
1291 WriteLine ("public object " + _result.ReadMethodName + " ()");
1293 WriteLine ("Reader.MoveToContent();");
1295 if (_typeMap is XmlTypeMapping)
1297 XmlTypeMapping typeMap = (XmlTypeMapping) _typeMap;
1299 if (_format == SerializationFormat.Literal)
1301 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode) {
1302 if (typeMap.TypeData.Type == typeof (XmlDocument))
1303 WriteLine ("return ReadXmlDocument (false);");
1305 WriteLine ("return ReadXmlNode (false);");
1307 WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
1308 WriteLine ("throw CreateUnknownNodeException();");
1311 WriteLine ("return " + GetReadObjectCall (typeMap, GetLiteral(typeMap.IsNullable), "true") + ";");
1316 WriteLine ("object ob = null;");
1317 WriteLine ("Reader.MoveToContent();");
1318 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1320 WriteLineInd ("if (Reader.LocalName == " + GetLiteral(typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
1321 WriteLine ("ob = ReadReferencedElement();");
1323 WriteLineInd ("else ");
1324 WriteLine ("throw CreateUnknownNodeException();");
1327 WriteLineInd ("else ");
1328 WriteLine ("UnknownNode(null);");
1331 WriteLine ("ReadReferencedElements();");
1332 WriteLine ("return ob;");
1333 RegisterReferencingMap (typeMap);
1337 WriteLine ("return " + GenerateReadMessage ((XmlMembersMapping)_typeMap) + ";");
1344 string GenerateReadMessage (XmlMembersMapping typeMap)
1346 WriteLine ("object[] parameters = new object[" + typeMap.Count + "];");
1349 if (typeMap.HasWrapperElement)
1351 if (_format == SerializationFormat.Encoded)
1353 WriteLine ("while (Reader.NodeType == System.Xml.XmlNodeType.Element)");
1355 WriteLine ("string root = Reader.GetAttribute (\"root\", " + GetLiteral(XmlSerializer.EncodingNamespace) + ");");
1356 WriteLine ("if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;");
1357 WriteLine ("ReadReferencedElement ();");
1358 WriteLine ("Reader.MoveToContent ();");
1361 WriteLine ("if (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1363 WriteLineInd ("if (Reader.IsEmptyElement) {");
1364 WriteLine ("Reader.Skip();");
1366 WriteLineInd ("else {");
1367 WriteLine ("Reader.ReadStartElement();");
1368 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1369 WriteLine ("ReadEndElement();");
1372 WriteLine ("Reader.MoveToContent();");
1377 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1379 WriteLine ("if (Reader.IsStartElement(" + GetLiteral(typeMap.ElementName) + ", " + GetLiteral(typeMap.Namespace) + "))");
1381 WriteLine ("if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }");
1382 WriteLine ("Reader.ReadStartElement();");
1383 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1384 WriteLine ("ReadEndElement();");
1385 WriteLine ("break;");
1387 WriteLineInd ("else ");
1388 WriteLine ("UnknownNode(null);");
1391 WriteLine ("Reader.MoveToContent();");
1396 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, _format == SerializationFormat.Encoded);
1398 if (_format == SerializationFormat.Encoded)
1399 WriteLine ("ReadReferencedElements();");
1401 return "parameters";
1404 void GenerateReadObject (XmlTypeMapping typeMap)
1407 if (_format == SerializationFormat.Literal) {
1408 WriteLine ("public " + typeMap.TypeFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
1409 isNullable = "isNullable";
1412 WriteLine ("public object " + GetReadObjectName (typeMap) + " ()");
1413 isNullable = "true";
1420 SetHookVar ("$TYPE", typeMap.TypeName);
1421 SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
1422 SetHookVar ("$NULLABLE", "isNullable");
1424 switch (typeMap.TypeData.SchemaType)
1426 case SchemaTypes.Class: GenerateReadClassInstance (typeMap, isNullable, "checkType"); break;
1427 case SchemaTypes.Array:
1428 string list = GenerateReadListElement (typeMap, null, isNullable, true);
1430 WriteLine ("return " + list + ";");
1432 case SchemaTypes.XmlNode: GenerateReadXmlNodeElement (typeMap, isNullable); break;
1433 case SchemaTypes.Primitive: GenerateReadPrimitiveElement (typeMap, isNullable); break;
1434 case SchemaTypes.Enum: GenerateReadEnumElement (typeMap, isNullable); break;
1435 case SchemaTypes.XmlSerializable: GenerateReadXmlSerializableElement (typeMap, isNullable); break;
1436 default: throw new Exception ("Unsupported map type");
1444 void GenerateReadClassInstance (XmlTypeMapping typeMap, string isNullable, string checkType)
1446 SetHookVar ("$OBJECT", "ob");
1447 if (!typeMap.TypeData.IsValueType)
1449 WriteLine (typeMap.TypeFullName + " ob = null;");
1451 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1452 WriteLine ("return ob;");
1456 if (_format == SerializationFormat.Literal) {
1457 WriteLine ("if (" + isNullable + " && ReadNull()) return null;");
1459 WriteLine ("if (checkType) ");
1463 WriteLine ("if (ReadNull()) return null;");
1469 WriteLine (typeMap.TypeFullName + " ob = new " + typeMap.TypeFullName + " ();");
1471 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1472 WriteLine ("return ob;");
1477 WriteLine ("System.Xml.XmlQualifiedName t = GetXsiType();");
1478 WriteLine ("if (t == null)");
1479 if (typeMap.TypeData.Type != typeof(object))
1482 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (new System.Xml.XmlQualifiedName(\"anyType\", System.Xml.Schema.XmlSchema.Namespace))") + ";");
1484 foreach (XmlTypeMapping realMap in typeMap.DerivedTypes)
1486 WriteLineInd ("else if (t.Name == " + GetLiteral (realMap.XmlType) + " && t.Namespace == " + GetLiteral (realMap.XmlTypeNamespace) + ")");
1487 WriteLine ("return " + GetReadObjectCall(realMap, isNullable, checkType) + ";");
1491 WriteLine ("else if (t.Name != " + GetLiteral (typeMap.XmlType) + " || t.Namespace != " + GetLiteral (typeMap.XmlTypeNamespace) + ")");
1492 if (typeMap.TypeData.Type == typeof(object))
1493 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
1495 WriteLine ("\tthrow CreateUnknownTypeException(t);");
1497 if (!typeMap.TypeData.IsValueType)
1499 if (_format == SerializationFormat.Literal)
1502 if (typeMap.TypeData.Type.IsAbstract) {
1504 WriteLine ("return ob;");
1509 WriteLine ("ob = new " + typeMap.TypeFullName + " ();");
1514 WriteLine ("Reader.MoveToElement();");
1517 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "ob", false, false);
1522 WriteLine ("return ob;");
1525 void GenerateReadMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, bool readByOrder)
1527 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
1528 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
1530 // Load the default value of members
1531 if (map.MembersWithDefault != null)
1533 ArrayList members = map.MembersWithDefault;
1534 for (int n=0; n<members.Count; n++) {
1535 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
1536 GenerateSetMemberValueFromAttr (mem, ob, GetLiteral (mem.DefaultValue), isValueList);
1540 // A value list cannot have attributes
1543 if (!isValueList && !GenerateReadHook (HookType.attributes, xmlMapType))
1547 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
1549 if (anyAttrMember != null)
1551 WriteLine ("int anyAttributeIndex = 0;");
1552 WriteLine (anyAttrMember.TypeData.FullTypeName + " anyAttributeArray = null;");
1555 WriteLine ("while (Reader.MoveToNextAttribute())");
1558 if (map.AttributeMembers != null) {
1559 foreach (XmlTypeMapMemberAttribute at in map.AttributeMembers)
1561 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (at.AttributeName) + " && Reader.NamespaceURI == " + GetLiteral (at.Namespace) + ") {");
1562 if (!GenerateReadMemberHook (xmlMapType, at)) {
1563 GenerateSetMemberValue (at, ob, GenerateGetValueFromXmlString ("Reader.Value", at.TypeData, at.MappedType), isValueList);
1570 WriteLineInd ((first?"":"else ") + "if (IsXmlnsAttribute (Reader.Name)) {");
1572 // If the map has NamespaceDeclarations,
1573 // then store this xmlns to the given member.
1574 // If the instance doesn't exist, then create.
1576 if (map.NamespaceDeclarations != null) {
1577 if (!GenerateReadMemberHook (xmlMapType, map.NamespaceDeclarations)) {
1578 string nss = ob + ".@" + map.NamespaceDeclarations.Name;
1579 WriteLine ("if (" + nss + " == null) " + nss + " = new XmlSerializerNamespaces ();");
1580 WriteLineInd ("if (Reader.Prefix == \"xmlns\")");
1581 WriteLine (nss + ".Add (Reader.LocalName, Reader.Value);");
1583 WriteLineInd ("else");
1584 WriteLine (nss + ".Add (\"\", Reader.Value);");
1591 WriteLineInd ("else {");
1593 if (anyAttrMember != null)
1595 if (!GenerateReadArrayMemberHook (xmlMapType, anyAttrMember, "anyAttributeIndex")) {
1596 WriteLine ("System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);");
1597 if (typeof(System.Xml.Schema.XmlSchemaAnnotated).IsAssignableFrom (xmlMapType))
1598 WriteLine ("ParseWsdlArrayType (attr);");
1599 GenerateAddListValue (anyAttrMember.TypeData, "anyAttributeArray", "anyAttributeIndex", GetCast (anyAttrMember.TypeData.ListItemTypeData, "attr"), true);
1602 WriteLine ("anyAttributeIndex++;");
1605 if (!GenerateReadHook (HookType.unknownAttribute, xmlMapType)) {
1606 WriteLine ("UnknownNode (" + ob + ");");
1614 if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
1617 WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.FullTypeName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
1618 GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
1627 WriteLine ("Reader.MoveToElement();");
1628 WriteLineInd ("if (Reader.IsEmptyElement) {");
1629 WriteLine ("Reader.Skip ();");
1630 GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
1631 WriteLine ("return " + ob + ";");
1635 WriteLine ("Reader.ReadStartElement();");
1640 WriteLine("Reader.MoveToContent();");
1643 if (!GenerateReadHook (HookType.elements, xmlMapType))
1645 string[] readFlag = null;
1646 if (map.ElementMembers != null && !readByOrder)
1648 string readFlagsVars = "bool ";
1649 readFlag = new string[map.ElementMembers.Count];
1650 for (int n=0; n<map.ElementMembers.Count; n++) {
1651 readFlag[n] = GetBoolTempVar ();
1652 if (n > 0) readFlagsVars += ", ";
1653 readFlagsVars += readFlag[n] + "=false";
1655 if (map.ElementMembers.Count > 0) WriteLine (readFlagsVars + ";");
1659 string[] indexes = null;
1660 string[] flatLists = null;
1661 string[] flatListsChoices = null;
1663 if (map.FlatLists != null)
1665 indexes = new string[map.FlatLists.Count];
1666 flatLists = new string[map.FlatLists.Count];
1668 string code = "int ";
1669 for (int n=0; n<map.FlatLists.Count; n++)
1671 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.FlatLists[n];
1672 indexes[n] = GetNumTempVar ();
1673 if (n > 0) code += ", ";
1674 code += indexes[n] + "=0";
1675 if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
1676 flatLists[n] = GetObTempVar ();
1678 WriteLine (mem.TypeData.FullTypeName + " " + flatLists[n] + ";");
1679 if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) {
1680 rval = GenerateGetMemberValue (mem, ob, isValueList);
1681 WriteLine (flatLists[n] + " = " + rval + ";");
1682 } else if (mem.TypeData.Type.IsArray) {
1683 rval = GenerateInitializeList (mem.TypeData);
1684 WriteLine (flatLists[n] + " = " + rval + ";");
1686 WriteLine (flatLists[n] + " = " + GenerateGetMemberValue (mem, ob, isValueList) + ";");
1687 WriteLineInd ("if (((object)" + flatLists[n] + ") == null) {");
1688 WriteLine (flatLists[n] + " = " + GenerateInitializeList (mem.TypeData) + ";");
1689 GenerateSetMemberValue (mem, ob, flatLists[n], isValueList);
1694 if (mem.ChoiceMember != null) {
1695 if (flatListsChoices == null)
1696 flatListsChoices = new string [map.FlatLists.Count];
1697 flatListsChoices[n] = GetObTempVar ();
1698 string rval = GenerateInitializeList (mem.ChoiceTypeData);
1699 WriteLine (mem.ChoiceTypeData.FullTypeName + " " + flatListsChoices[n] + " = " + rval + ";");
1702 WriteLine (code + ";");
1706 if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
1708 _fixupCallbacks.Add (xmlMap);
1709 WriteLine ("Fixup fixup = new Fixup(" + ob + ", new XmlSerializationFixupCallback(" + GetFixupCallbackName (xmlMap) + "), " + map.ElementMembers.Count + ");");
1710 WriteLine ("AddFixup (fixup);");
1714 ArrayList infos = null;
1718 if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
1723 infos = new ArrayList ();
1724 infos.AddRange (map.AllElementInfos);
1725 maxInd = infos.Count;
1727 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
1729 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1734 for (int ind = 0; ind < maxInd; ind++)
1736 XmlTypeMapElementInfo info = readByOrder ? map.GetElement (ind) : (XmlTypeMapElementInfo) infos [ind];
1740 if (info.IsTextElement || info.IsUnnamedAnyElement) continue;
1741 string elemCond = first ? "" : "else ";
1743 if (!(info.Member.IsReturnValue && _format == SerializationFormat.Encoded)) {
1744 elemCond += "Reader.LocalName == " + GetLiteral (info.ElementName);
1745 if (!map.IgnoreMemberNamespace) elemCond += " && Reader.NamespaceURI == " + GetLiteral (info.Namespace);
1748 elemCond += "!" + readFlag[info.Member.Index] + ") {";
1749 WriteLineInd (elemCond);
1752 if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
1754 if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
1756 string list = GetObTempVar ();
1757 WriteLine ("object " + list + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1758 RegisterReferencingMap (info.MappedType);
1760 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // Already read
1761 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1762 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.FullTypeName) + ");");
1764 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1767 if (!info.MappedType.TypeData.Type.IsArray)
1769 WriteLineInd ("else {");
1770 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1771 WriteLine (list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1773 WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1774 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1776 WriteLine ("AddFixup (new CollectionFixup (" + list + ", new XmlSerializationCollectionFixupCallback (" + GetFillListName(info.Member.TypeData) + "), fixup.Ids[" + info.Member.Index + "]));");
1777 WriteLine ("fixup.Ids[" + info.Member.Index + "] = null;"); // The member already has the value, no further fix needed.
1783 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1784 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) {
1785 GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
1786 } else if (info.MappedType.TypeData.Type.IsArray) {
1787 if (info.IsNullable)
1788 GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
1790 string list = GetObTempVar ();
1791 WriteLine (info.MappedType.TypeFullName + " " + list + " = " + GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true) + ";");
1792 WriteLineInd ("if (((object)" + list + ") != null) {");
1793 GenerateSetMemberValue (info.Member, ob, list, isValueList);
1797 string list = GetObTempVar ();
1798 WriteLine (info.MappedType.TypeFullName + " " + list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1799 WriteLineInd ("if (((object)" + list + ") == null) {");
1800 WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1801 GenerateSetMemberValue (info.Member, ob, list, isValueList);
1803 GenerateReadListElement (info.MappedType, list, GetLiteral(info.IsNullable), true);
1809 WriteLine (readFlag[info.Member.Index] + " = true;");
1811 else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
1813 XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
1814 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1815 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
1816 if (mem.ChoiceMember != null) {
1817 GenerateAddListValue (mem.ChoiceTypeData, flatListsChoices[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetLiteral (info.ChoiceValue), true);
1821 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1823 else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
1825 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
1826 if (mem.TypeData.IsListType) {
1827 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1828 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
1831 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1834 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1835 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1840 else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
1843 WriteLine (readFlag[info.Member.Index] + " = true;");
1844 if (_format == SerializationFormat.Encoded)
1846 string val = GetObTempVar ();
1847 RegisterReferencingMap (info.MappedType);
1849 if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
1850 WriteLine ("object " + val + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1852 WriteLine ("object " + val + " = ReadReferencingElement (" + GetLiteral(info.Member.TypeData.XmlType) + ", " + GetLiteral(System.Xml.Schema.XmlSchema.Namespace) + ", out fixup.Ids[" + info.Member.Index + "]);");
1854 if (info.MultiReferenceType)
1855 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // already read
1857 WriteLineInd ("if (" + val + " != null) {"); // null value
1859 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,val), isValueList);
1862 else if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1863 if (info.ChoiceValue != null) {
1864 XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement) info.Member;
1865 WriteLine (ob + ".@" + imem.ChoiceMember + " = " + GetLiteral(info.ChoiceValue) + ";");
1867 GenerateSetMemberValue (info.Member, ob, GenerateReadObjectElement (info), isValueList);
1872 throw new InvalidOperationException ("Unknown member type");
1877 WriteLine ("Reader.MoveToContent();");
1883 if (!first) WriteLineInd ("else {");
1885 if (map.DefaultAnyElementMember != null)
1887 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
1888 if (mem.TypeData.IsListType) {
1889 if (!GenerateReadArrayMemberHook (xmlMapType, mem, indexes[mem.FlatArrayIndex])) {
1890 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
1893 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1895 else if (! GenerateReadMemberHook (xmlMapType, mem)) {
1896 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1901 if (!GenerateReadHook (HookType.unknownElement, xmlMapType)) {
1902 WriteLine ("UnknownNode (" + ob + ");");
1907 if (!first) WriteLineUni ("}");
1911 if (map.XmlTextCollector != null)
1913 WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)");
1916 if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
1918 XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
1919 XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
1920 TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
1922 if (!GenerateReadArrayMemberHook (xmlMapType, map.XmlTextCollector, indexes[mem.FlatArrayIndex])) {
1923 string val = (itype.Type == typeof (string)) ? "Reader.ReadString()" : GetReadXmlNode (itype, false);
1924 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], val, true);
1927 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1929 else if (!GenerateReadMemberHook (xmlMapType, map.XmlTextCollector))
1931 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
1932 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
1933 if (info.TypeData.Type == typeof (string))
1934 GenerateSetMemberValue (mem, ob, "ReadString (" + GenerateGetMemberValue (mem, ob, isValueList) + ")", isValueList);
1936 GenerateSetMemberValue (mem, ob, GenerateGetValueFromXmlString ("Reader.ReadString()", info.TypeData, info.MappedType), isValueList);
1943 WriteLine ("\tUnknownNode(" + ob + ");");
1945 WriteLine ("Reader.MoveToContent();");
1949 WriteLine ("Reader.MoveToContent();");
1951 if (flatLists != null)
1954 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
1956 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
1958 string list = flatLists[mem.FlatArrayIndex];
1959 if (mem.TypeData.Type.IsArray)
1960 WriteLine (list + " = (" + mem.TypeData.FullTypeName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
1961 if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList) && mem.TypeData.Type.IsArray)
1962 GenerateSetMemberValue (mem, ob, list, isValueList);
1966 if (flatListsChoices != null)
1969 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
1971 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
1972 if (mem.ChoiceMember == null) continue;
1974 string list = flatListsChoices[mem.FlatArrayIndex];
1975 WriteLine (list + " = (" + mem.ChoiceTypeData.FullTypeName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.ChoiceTypeData.Type.GetElementType()) + ", true);");
1976 WriteLine (ob + ".@" + mem.ChoiceMember + " = " + list + ";");
1980 GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
1988 WriteLine ("ReadEndElement();");
1992 void GenerateSetListMembersDefaults (XmlTypeMapping typeMap, ClassMap map, string ob, bool isValueList)
1994 if (map.ListMembers != null)
1996 ArrayList members = map.ListMembers;
1997 for (int n=0; n<members.Count; n++) {
1998 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
1999 if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
2001 WriteLineInd ("if (" + GenerateGetMemberValue (mem, ob, isValueList) + " == null) {");
2002 GenerateSetMemberValue (mem, ob, GenerateInitializeList (mem.TypeData), isValueList);
2008 bool IsReadOnly (XmlTypeMapping map, XmlTypeMapMember member, TypeData memType, bool isValueList)
2010 if (isValueList) return !memType.HasPublicConstructor;
2011 else return member.IsReadOnly (map.TypeData.Type) || !memType.HasPublicConstructor;
2014 void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
2016 if (isValueList) WriteLine (ob + "[" + member.GlobalIndex + "] = " + value + ";");
2018 WriteLine (ob + ".@" + member.Name + " = " + value + ";");
2019 if (member.IsOptionalValueType)
2020 WriteLine (ob + "." + member.Name + "Specified = true;");
2024 void GenerateSetMemberValueFromAttr (XmlTypeMapMember member, string ob, string value, bool isValueList)
2026 // Enumeration values specified in custom attributes are stored as integer
2027 // values if the custom attribute property is of type object. So, it is
2028 // necessary to convert to the enum type before asigning the value to the field.
2030 if (member.TypeData.Type.IsEnum)
2031 value = GetCast (member.TypeData.Type, value);
2032 GenerateSetMemberValue (member, ob, value, isValueList);
2035 string GenerateReadObjectElement (XmlTypeMapElementInfo elem)
2037 switch (elem.TypeData.SchemaType)
2039 case SchemaTypes.XmlNode:
2040 return GetReadXmlNode (elem.TypeData, true);
2042 case SchemaTypes.Primitive:
2043 case SchemaTypes.Enum:
2044 return GenerateReadPrimitiveValue (elem);
2046 case SchemaTypes.Array:
2047 return GenerateReadListElement (elem.MappedType, null, GetLiteral(elem.IsNullable), true);
2049 case SchemaTypes.Class:
2050 return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
2052 case SchemaTypes.XmlSerializable:
2053 return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.FullTypeName + " ())");
2056 throw new NotSupportedException ("Invalid value type");
2060 string GenerateReadPrimitiveValue (XmlTypeMapElementInfo elem)
2062 if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
2063 if (elem.IsNullable) return "ReadNullableQualifiedName ()";
2064 else return "ReadElementQualifiedName ()";
2066 else if (elem.IsNullable)
2067 return GenerateGetValueFromXmlString ("ReadNullableString ()", elem.TypeData, elem.MappedType);
2069 return GenerateGetValueFromXmlString ("Reader.ReadElementString ()", elem.TypeData, elem.MappedType);
2072 string GenerateGetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
2074 if (typeData.SchemaType == SchemaTypes.Array)
2075 return GenerateReadListString (typeMap, value);
2076 else if (typeData.SchemaType == SchemaTypes.Enum)
2077 return GenerateGetEnumValue (typeMap, value);
2078 else if (typeData.Type == typeof (XmlQualifiedName))
2079 return "ToXmlQualifiedName (" + value + ")";
2081 return XmlCustomFormatter.GenerateFromXmlString (typeData, value);
2084 string GenerateReadListElement (XmlTypeMapping typeMap, string list, string isNullable, bool canCreateInstance)
2086 Type listType = typeMap.TypeData.Type;
2087 ListMap listMap = (ListMap)typeMap.ObjectMap;
2088 bool doNullCheck = typeMap.TypeData.Type.IsArray;
2090 if (canCreateInstance && typeMap.TypeData.HasPublicConstructor)
2093 list = GetObTempVar ();
2094 WriteLine (typeMap.TypeFullName + " " + list + " = null;");
2096 WriteLineInd ("if (!ReadNull()) {");
2097 WriteLine (list + " = " + GenerateCreateList (listType) + ";");
2100 WriteLineInd ("if (!ReadNull()) {");
2106 WriteLineInd ("if (((object)" + list + ") == null)");
2107 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
2109 doNullCheck = false;
2112 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
2117 WriteLineInd ("if (Reader.IsEmptyElement) {");
2118 WriteLine ("Reader.Skip();");
2119 if (listType.IsArray)
2120 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", false);");
2123 WriteLineInd ("} else {");
2125 string index = GetNumTempVar ();
2126 WriteLine ("int " + index + " = 0;");
2127 WriteLine ("Reader.ReadStartElement();");
2128 WriteLine ("Reader.MoveToContent();");
2131 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
2133 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
2137 foreach (XmlTypeMapElementInfo elemInfo in listMap.ItemInfo)
2139 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (elemInfo.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (elemInfo.Namespace) + ") {");
2140 GenerateAddListValue (typeMap.TypeData, list, index, GenerateReadObjectElement (elemInfo), false);
2141 WriteLine (index + "++;");
2145 if (!first) WriteLine ("else UnknownNode (null);");
2146 else WriteLine ("UnknownNode (null);");
2149 WriteLine ("else UnknownNode (null);");
2151 WriteLine ("Reader.MoveToContent();");
2154 WriteLine ("ReadEndElement();");
2156 if (listType.IsArray)
2157 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", false);");
2166 string GenerateReadListString (XmlTypeMapping typeMap, string values)
2168 Type listType = typeMap.TypeData.Type;
2169 ListMap listMap = (ListMap)typeMap.ObjectMap;
2170 string itemType = listType.GetElementType().FullName;
2172 string list = GetObTempVar ();
2173 WriteLine (itemType + "[] " + list + ";");
2175 string var = GetStrTempVar ();
2176 WriteLine ("string " + var + " = " + values + ".Trim();");
2177 WriteLineInd ("if (" + var + " != string.Empty) {");
2179 string valueArray = GetObTempVar ();
2180 WriteLine ("string[] " + valueArray + " = " + var + ".Split (' ');");
2182 WriteLine (list + " = new " + GetArrayDeclaration (listType, valueArray + ".Length") + ";");
2184 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
2186 string index = GetNumTempVar ();
2187 WriteLineInd ("for (int " + index + " = 0; " + index + " < " + valueArray + ".Length; " + index + "++)");
2188 WriteLine (list + "[" + index + "] = " + GenerateGetValueFromXmlString (valueArray + "[" + index + "]", info.TypeData, info.MappedType) + ";");
2192 WriteLine ("\t" + list + " = new " + GetArrayDeclaration (listType, "0") + ";");
2197 string GetArrayDeclaration (Type type, string length)
2199 Type t = type.GetElementType();
2200 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
2201 sb.Append ('[').Append (length).Append (']');
2204 t = t.GetElementType();
2206 sb.Insert (0, t.FullName);
2207 return sb.ToString ();
2210 void GenerateAddListValue (TypeData listType, string list, string index, string value, bool canCreateInstance)
2212 Type type = listType.Type;
2215 WriteLine (list + " = (" + type.FullName + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
2216 WriteLine (list + "[" + index + "] = " + value + ";");
2218 else // Must be IEnumerable
2220 WriteLine ("if (((object)" + list + ") == null)");
2221 if (canCreateInstance)
2222 WriteLine ("\t" + list + " = new " + listType.FullTypeName + "();");
2224 WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.FullTypeName) + ");");
2226 WriteLine (list + ".Add (" + value + ");");
2230 string GenerateCreateList (Type listType)
2232 if (listType.IsArray)
2233 return "(" + listType.FullName + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
2235 return "new " + listType.FullName + "()";
2238 string GenerateInitializeList (TypeData listType)
2240 if (listType.Type.IsArray)
2243 return "new " + listType.Type.FullName + "()";
2246 void GenerateFillerCallbacks ()
2248 foreach (TypeData td in _listsToFill)
2250 string metName = GetFillListName (td);
2251 WriteLine ("void " + metName + " (object list, object source)");
2253 WriteLine ("if (((object)list) == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.FullTypeName) + ");");
2256 WriteLine (td.FullTypeName + " dest = (" + td.FullTypeName + ") list;");
2257 WriteLine ("foreach (object ob in (IEnumerable)source)");
2258 WriteLine ("\tdest.Add (" + GetCast (td.ListItemTypeData, "ob") + ");");
2264 void GenerateReadXmlNodeElement (XmlTypeMapping typeMap, string isNullable)
2266 WriteLine ("return " + GetReadXmlNode (typeMap.TypeData, false) + ";");
2269 void GenerateReadPrimitiveElement (XmlTypeMapping typeMap, string isNullable)
2271 WriteLine ("XmlQualifiedName t = GetXsiType();");
2272 WriteLine ("if (t == null) t = new XmlQualifiedName (" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.Namespace) + ");");
2273 WriteLine ("return " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
2276 void GenerateReadEnumElement (XmlTypeMapping typeMap, string isNullable)
2278 WriteLine ("Reader.ReadStartElement ();");
2279 WriteLine (typeMap.TypeFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
2280 WriteLineInd ("if (Reader.NodeType != XmlNodeType.None)");
2281 WriteLineUni ("Reader.ReadEndElement ();");
2282 WriteLine ("return res;");
2285 string GenerateGetEnumValue (XmlTypeMapping typeMap, string val)
2287 return GetGetEnumValueName (typeMap) + " (" + val + ")";
2290 void GenerateGetEnumValue (XmlTypeMapping typeMap)
2292 string metName = GetGetEnumValueName (typeMap);
2293 EnumMap map = (EnumMap) typeMap.ObjectMap;
2297 string switchMethod = metName + "_Switch";
2298 WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2300 WriteLine ("xmlName = xmlName.Trim();");
2301 WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeFullName + ")0;");
2302 WriteLine (typeMap.TypeFullName + " sb = (" + typeMap.TypeFullName + ")0;");
2303 WriteLine ("string[] enumNames = xmlName.Split (null);");
2304 WriteLine ("foreach (string name in enumNames)");
2306 WriteLine ("if (name == string.Empty) continue;");
2307 WriteLine ("sb |= " + switchMethod + " (name); ");
2309 WriteLine ("return sb;");
2312 metName = switchMethod;
2315 WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2317 GenerateGetSingleEnumValue (typeMap, "xmlName");
2322 void GenerateGetSingleEnumValue (XmlTypeMapping typeMap, string val)
2324 EnumMap map = (EnumMap) typeMap.ObjectMap;
2325 WriteLine ("switch (" + val + ")");
2327 foreach (EnumMap.EnumMapMember mem in map.Members)
2329 WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeFullName + "." + mem.EnumName + ";");
2331 WriteLineInd ("default:");
2332 WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeFullName + "));");
2337 void GenerateReadXmlSerializableElement (XmlTypeMapping typeMap, string isNullable)
2339 WriteLine ("Reader.MoveToContent ();");
2340 WriteLine ("if (Reader.NodeType == XmlNodeType.Element)");
2342 WriteLine ("if (Reader.LocalName == " + GetLiteral (typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
2343 WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.FullTypeName + "());");
2345 WriteLine ("\tthrow CreateUnknownNodeException ();");
2347 WriteLine ("else UnknownNode (null);");
2349 WriteLine ("return null;");
2352 void GenerateReadInitCallbacks ()
2354 WriteLine ("protected override void InitCallbacks ()");
2357 if (_format == SerializationFormat.Encoded)
2359 foreach (XmlMapping xmap in _mapsToGenerate)
2361 XmlTypeMapping map = xmap as XmlTypeMapping;
2362 if (map == null) continue;
2363 if (map.TypeData.SchemaType == SchemaTypes.Class || map.TypeData.SchemaType == SchemaTypes.Enum)
2364 WriteMetCall ("AddReadCallback", GetLiteral (map.XmlType), GetLiteral(map.Namespace), GetTypeOf(map.TypeData.Type), "new XmlSerializationReadCallback (" + GetReadObjectName (map) + ")");
2371 WriteLine ("protected override void InitIDs ()");
2377 void GenerateFixupCallbacks ()
2379 foreach (XmlMapping map in _fixupCallbacks)
2381 bool isList = map is XmlMembersMapping;
2382 string tname = !isList ? ((XmlTypeMapping)map).TypeFullName : "object[]";
2383 WriteLine ("void " + GetFixupCallbackName (map) + " (object obfixup)");
2385 WriteLine ("Fixup fixup = (Fixup)obfixup;");
2386 WriteLine (tname + " source = (" + tname + ") fixup.Source;");
2387 WriteLine ("string[] ids = fixup.Ids;");
2390 ClassMap cmap = (ClassMap)map.ObjectMap;
2391 ICollection members = cmap.ElementMembers;
2392 if (members != null) {
2393 foreach (XmlTypeMapMember member in members)
2395 WriteLineInd ("if (ids[" + member.Index + "] != null)");
2396 string val = "GetTarget(ids[" + member.Index + "])";
2397 if (!isList) val = GetCast (member.TypeData, val);
2398 GenerateSetMemberValue (member, "source", val, isList);
2407 string GetReadXmlNode (TypeData type, bool wrapped)
2409 if (type.Type == typeof (XmlDocument))
2410 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlDocument)), "ReadXmlDocument (" + GetLiteral(wrapped) + ")");
2412 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlNode)), "ReadXmlNode (" + GetLiteral(wrapped) + ")");
2417 #region Helper methods
2419 //*******************************************************
2423 ArrayList _listsToFill = new ArrayList ();
2424 Hashtable _hookVariables;
2425 Stack _hookContexts;
2426 Stack _hookOpenHooks;
2429 public HookType HookType;
2431 public string Member;
2432 public HookDir Direction;
2437 _hookContexts = new Stack ();
2438 _hookOpenHooks = new Stack ();
2439 _hookVariables = new Hashtable ();
2442 void PushHookContext ()
2444 _hookContexts.Push (_hookVariables);
2445 _hookVariables = (Hashtable) _hookVariables.Clone ();
2448 void PopHookContext ()
2450 _hookVariables = (Hashtable) _hookContexts.Pop ();
2453 void SetHookVar (string var, string value)
2455 _hookVariables [var] = value;
2458 bool GenerateReadHook (HookType hookType, Type type)
2460 return GenerateHook (hookType, HookDir.Read, type, null);
2463 bool GenerateWriteHook (HookType hookType, Type type)
2465 return GenerateHook (hookType, HookDir.Write, type, null);
2468 bool GenerateWriteMemberHook (Type type, XmlTypeMapMember member)
2470 SetHookVar ("$MEMBER", member.Name);
2471 return GenerateHook (HookType.member, HookDir.Write, type, member.Name);
2474 bool GenerateReadMemberHook (Type type, XmlTypeMapMember member)
2476 SetHookVar ("$MEMBER", member.Name);
2477 return GenerateHook (HookType.member, HookDir.Read, type, member.Name);
2480 bool GenerateReadArrayMemberHook (Type type, XmlTypeMapMember member, string index)
2482 SetHookVar ("$INDEX", index);
2483 return GenerateReadMemberHook (type, member);
2486 bool MemberHasReadReplaceHook (Type type, XmlTypeMapMember member)
2488 if (_config == null) return false;
2489 return _config.GetHooks (HookType.member, HookDir.Read, HookAction.Replace, type, member.Name).Count > 0;
2492 bool GenerateHook (HookType hookType, HookDir dir, Type type, string member)
2494 GenerateHooks (hookType, dir, type, null, HookAction.InsertBefore);
2495 if (GenerateHooks (hookType, dir, type, null, HookAction.Replace))
2497 GenerateHooks (hookType, dir, type, null, HookAction.InsertAfter);
2502 HookInfo hi = new HookInfo ();
2503 hi.HookType = hookType;
2507 _hookOpenHooks.Push (hi);
2512 void GenerateEndHook ()
2514 HookInfo hi = (HookInfo) _hookOpenHooks.Pop();
2515 GenerateHooks (hi.HookType, hi.Direction, hi.Type, hi.Member, HookAction.InsertAfter);
2518 bool GenerateHooks (HookType hookType, HookDir dir, Type type, string member, HookAction action)
2520 if (_config == null) return false;
2521 ArrayList hooks = _config.GetHooks (hookType, dir, action, type, null);
2522 if (hooks.Count == 0) return false;
2523 foreach (Hook hook in hooks)
2525 string code = hook.GetCode (action);
2526 foreach (DictionaryEntry de in _hookVariables)
2527 code = code.Replace ((string)de.Key, (string)de.Value);
2528 WriteMultilineCode (code);
2533 string GetRootTypeName ()
2535 if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeFullName;
2536 else return "object[]";
2539 string GetNumTempVar ()
2541 return "n" + (_tempVarId++);
2544 string GetObTempVar ()
2546 return "o" + (_tempVarId++);
2549 string GetStrTempVar ()
2551 return "s" + (_tempVarId++);
2554 string GetBoolTempVar ()
2556 return "b" + (_tempVarId++);
2559 string GetUniqueName (string uniqueGroup, object ob, string name)
2561 name = name.Replace ("[]","_array");
2562 Hashtable names = (Hashtable) _uniqueNames [uniqueGroup];
2563 if (names == null) {
2564 names = new Hashtable ();
2565 _uniqueNames [uniqueGroup] = names;
2568 string res = (string) names [ob];
2569 if (res != null) return res;
2571 foreach (string n in names.Values)
2572 if (n == name) return GetUniqueName (uniqueGroup, ob, name + (_methodId++));
2578 void RegisterReferencingMap (XmlTypeMapping typeMap)
2580 if (typeMap != null && !_mapsToGenerate.Contains (typeMap))
2581 _mapsToGenerate.Add (typeMap);
2584 string GetWriteObjectName (XmlTypeMapping typeMap)
2586 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2587 return GetUniqueName ("rw", typeMap, "WriteObject_" + typeMap.XmlType);
2590 string GetReadObjectName (XmlTypeMapping typeMap)
2592 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2593 return GetUniqueName ("rr", typeMap, "ReadObject_" + typeMap.XmlType);
2596 string GetGetEnumValueName (XmlTypeMapping typeMap)
2598 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2599 return GetUniqueName ("ge", typeMap, "GetEnumValue_" + typeMap.XmlType);
2602 string GetWriteObjectCallbackName (XmlTypeMapping typeMap)
2604 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2605 return GetUniqueName ("wc", typeMap, "WriteCallback_" + typeMap.XmlType);
2608 string GetFixupCallbackName (XmlMapping typeMap)
2610 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2612 if (typeMap is XmlTypeMapping)
2613 return GetUniqueName ("fc", typeMap, "FixupCallback_" + ((XmlTypeMapping)typeMap).XmlType);
2615 return GetUniqueName ("fc", typeMap, "FixupCallback__Message");
2618 string GetUniqueClassName (string s)
2620 return classNames.AddUnique (s, null);
2623 string GetReadObjectCall (XmlTypeMapping typeMap, string isNullable, string checkType)
2625 if (_format == SerializationFormat.Literal)
2626 return GetReadObjectName (typeMap) + " (" + isNullable + ", " + checkType + ")";
2628 return GetCast (typeMap.TypeData, GetReadObjectName (typeMap) + " ()");
2631 string GetFillListName (TypeData td)
2633 if (!_listsToFill.Contains (td)) _listsToFill.Add (td);
2634 return GetUniqueName ("fl", td, "Fill_" + td.TypeName);
2637 string GetCast (TypeData td, TypeData tdval, string val)
2639 if (td.FullTypeName == tdval.FullTypeName) return val;
2640 else return GetCast (td, val);
2643 string GetCast (TypeData td, string val)
2645 return "((" + td.FullTypeName + ") " + val + ")";
2648 string GetCast (Type td, string val)
2650 return "((" + td.FullName + ") " + val + ")";
2653 string GetTypeOf (TypeData td)
2655 return "typeof(" + td.FullTypeName + ")";
2658 string GetTypeOf (Type td)
2660 return "typeof(" + td.FullName.Replace ('+','.') + ")";
2663 string GetLiteral (object ob)
2665 if (ob == null) return "null";
2666 if (ob is string) return "\"" + ob.ToString().Replace("\"","\"\"") + "\"";
2667 if (ob is bool) return ((bool)ob) ? "true" : "false";
2668 if (ob is XmlQualifiedName) {
2669 XmlQualifiedName qn = (XmlQualifiedName)ob;
2670 return "new XmlQualifiedName (" + GetLiteral(qn.Name) + "," + GetLiteral(qn.Namespace) + ")";
2672 if (ob is Enum) return ob.GetType () + "." + ob;
2673 return (ob is IFormattable) ? ((IFormattable) ob).ToString (null, CultureInfo.InvariantCulture) : ob.ToString ();
2676 void WriteLineInd (string code)
2682 void WriteLineUni (string code)
2684 if (_indent > 0) _indent--;
2688 void Write (string code)
2690 if (code.Length > 0)
2691 _writer.Write (new String ('\t', _indent));
2692 _writer.Write (code);
2695 void WriteUni (string code)
2697 if (_indent > 0) _indent--;
2698 _writer.Write (code);
2699 _writer.WriteLine (string.Empty);
2702 void WriteLine (string code)
2704 if (code.Length > 0)
2705 _writer.Write (new String ('\t',_indent));
2706 _writer.WriteLine (code);
2709 void WriteMultilineCode (string code)
2711 string tabs = new string ('\t',_indent);
2712 code = code.Replace ("\r","");
2713 code = code.Replace ("\t","");
2714 while (code.StartsWith ("\n")) code = code.Substring (1);
2715 while (code.EndsWith ("\n")) code = code.Substring (0, code.Length - 1);
2716 code = code.Replace ("\n", "\n" + tabs);
2720 string Params (params string[] pars)
2723 foreach (string p in pars)
2725 if (res != "") res += ", ";
2731 void WriteMetCall (string method, params string[] pars)
2733 WriteLine (method + " (" + Params (pars) + ");");
2745 internal class GenerationResult
2747 public XmlMapping Mapping;
2748 public string ReaderClassName;
2749 public string ReadMethodName;
2750 public string WriterClassName;
2751 public string WriteMethodName;
2752 public string Namespace;
2753 public string SerializerClassName;