2 // System.Xml.Serialization.SerializationCodeGenerator.cs:
5 // Lluis Sanchez Gual (lluis@ximian.com)
6 // Atsushi Enomoto (atsushi@ximian.com)
8 // (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
9 // Copyright (C) 2006 Novell, Inc.
13 // Permission is hereby granted, free of charge, to any person obtaining
14 // a copy of this software and associated documentation files (the
15 // "Software"), to deal in the Software without restriction, including
16 // without limitation the rights to use, copy, modify, merge, publish,
17 // distribute, sublicense, and/or sell copies of the Software, and to
18 // permit persons to whom the Software is furnished to do so, subject to
19 // the following conditions:
21 // The above copyright notice and this permission notice shall be
22 // included in all copies or substantial portions of the Software.
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 using System.Reflection;
35 using System.Xml.Serialization;
36 using System.Collections;
37 using System.Globalization;
40 namespace System.Xml.Serialization
42 internal class SerializationCodeGenerator
45 SerializationFormat _format;
49 Hashtable _uniqueNames = new Hashtable();
51 SerializerInfo _config;
52 ArrayList _mapsToGenerate = new ArrayList ();
53 ArrayList _fixupCallbacks;
54 ArrayList _referencedTypes = new ArrayList ();
55 GenerationResult[] _results;
56 GenerationResult _result;
57 XmlMapping[] _xmlMaps;
59 CodeIdentifiers classNames = new CodeIdentifiers ();
61 public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
65 public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
71 public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
73 _xmlMaps = new XmlMapping [] {xmlMap};
77 public static void Generate (string configFileName, string outputPath)
79 SerializationCodeGeneratorConfiguration cnf = null;
80 StreamReader sr = new StreamReader (configFileName);
83 XmlReflectionImporter ri = new XmlReflectionImporter ();
84 ri.AllowPrivateTypes = true;
85 XmlSerializer ser = new XmlSerializer (ri.ImportTypeMapping (typeof (SerializationCodeGeneratorConfiguration)));
86 cnf = (SerializationCodeGeneratorConfiguration) ser.Deserialize (sr);
93 if (outputPath == null) outputPath = "";
95 CodeIdentifiers ids = new CodeIdentifiers ();
96 if (cnf.Serializers != null)
98 foreach (SerializerInfo info in cnf.Serializers)
101 if (info.Assembly != null)
105 asm = Assembly.Load (info.Assembly);
107 asm = Assembly.LoadFrom (info.Assembly);
109 type = asm.GetType (info.ClassName, true);
112 type = Type.GetType (info.ClassName);
114 if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
116 string file = info.OutFileName;
117 if (file == null || file.Length == 0) {
118 int i = info.ClassName.LastIndexOf (".");
119 if (i != -1) file = info.ClassName.Substring (i+1);
120 else file = info.ClassName;
121 file = ids.AddUnique (file, type) + "Serializer.cs";
123 StreamWriter writer = new StreamWriter (Path.Combine (outputPath, file));
129 if (info.SerializationFormat == SerializationFormat.Literal) {
130 XmlReflectionImporter ri = new XmlReflectionImporter ();
131 map = ri.ImportTypeMapping (type);
134 SoapReflectionImporter ri = new SoapReflectionImporter ();
135 map = ri.ImportTypeMapping (type);
138 SerializationCodeGenerator gen = new SerializationCodeGenerator (map, info);
139 gen.GenerateSerializers (writer);
149 public void GenerateSerializers (TextWriter writer)
152 _results = new GenerationResult [_xmlMaps.Length];
154 WriteLine ("using System;");
155 WriteLine ("using System.Xml;");
156 WriteLine ("using System.Xml.Schema;");
157 WriteLine ("using System.Xml.Serialization;");
158 WriteLine ("using System.Text;");
159 WriteLine ("using System.Collections;");
160 WriteLine ("using System.Globalization;");
161 if (_config != null && _config.NamespaceImports != null && _config.NamespaceImports.Length > 0) {
162 foreach (string ns in _config.NamespaceImports)
163 WriteLine ("using " + ns + ";");
167 string readerClassName = null;
168 string writerClassName = null;
169 string baseClassName = null;
170 string implClassName = null;
171 string namspace = null;
175 readerClassName = _config.ReaderClassName;
176 writerClassName = _config.WriterClassName;
177 baseClassName = _config.BaseSerializerClassName;
178 implClassName = _config.ImplementationClassName;
179 namspace = _config.Namespace;
182 if (readerClassName == null || readerClassName.Length == 0)
183 readerClassName = "GeneratedReader";
185 if (writerClassName == null || writerClassName.Length == 0)
186 writerClassName = "GeneratedWriter";
187 if (baseClassName == null || baseClassName.Length == 0)
188 baseClassName = "BaseXmlSerializer";
189 if (implClassName == null || implClassName.Length == 0)
190 implClassName = "XmlSerializerContract";
191 readerClassName = GetUniqueClassName (readerClassName);
192 writerClassName = GetUniqueClassName (writerClassName);
193 baseClassName = GetUniqueClassName (baseClassName);
194 implClassName = GetUniqueClassName (implClassName);
195 Hashtable mapsByNamespace = new Hashtable ();
196 Hashtable generatedMaps = new Hashtable ();
198 for (int n=0; n<_xmlMaps.Length; n++)
200 _typeMap = _xmlMaps [n];
201 if (_typeMap == null) continue;
203 _result = generatedMaps [_typeMap] as GenerationResult;
204 if (_result != null) {
205 _results[n] = _result;
209 _result = new GenerationResult ();
210 _results[n] = _result;
212 generatedMaps [_typeMap] = _result;
215 if (_typeMap is XmlTypeMapping) typeName = CodeIdentifier.MakeValid (((XmlTypeMapping)_typeMap).TypeData.CSharpName);
216 else typeName = ((XmlMembersMapping)_typeMap).ElementName;
218 _result.ReaderClassName = readerClassName;
219 _result.WriterClassName = writerClassName;
220 _result.BaseSerializerClassName = baseClassName;
221 _result.ImplementationClassName = implClassName;
223 if (namspace == null || namspace.Length == 0)
224 _result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
226 _result.Namespace = namspace;
228 _result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
229 _result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
231 _result.Mapping = _typeMap;
233 ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
235 maps = new ArrayList ();
236 mapsByNamespace [_result.Namespace] = maps;
241 foreach (DictionaryEntry entry in mapsByNamespace)
243 ArrayList maps = (ArrayList) entry.Value;
245 WriteLine ("namespace " + entry.Key);
248 if (_config == null || !_config.NoReader)
249 GenerateReader (readerClassName, maps);
251 if (_config == null || !_config.NoWriter)
252 GenerateWriter (writerClassName, maps);
256 GenerateContract (maps);
264 public GenerationResult[] GenerationResults
266 get { return _results; }
269 public ArrayList ReferencedTypes
271 get { return _referencedTypes; }
274 void UpdateGeneratedTypes (ArrayList list)
276 for (int n=0; n<list.Count; n++)
278 XmlTypeMapping map = list[n] as XmlTypeMapping;
279 if (map != null && !_referencedTypes.Contains (map.TypeData.Type))
280 _referencedTypes.Add (map.TypeData.Type);
284 static string ToCSharpFullName (Type type)
286 return TypeData.ToCSharpName (type, true);
289 #region Writer Generation
291 //*******************************************************
292 // Contract generation
296 public void GenerateContract (ArrayList generatedMaps)
298 // Write the base serializer
300 if (generatedMaps.Count == 0) return;
302 GenerationResult main = (GenerationResult) generatedMaps[0];
304 string baseSerializerName = main.BaseSerializerClassName;
305 string access_mod = (_config == null || !_config.GenerateAsInternal) ? "public" : "internal";
308 WriteLine (access_mod + " class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
310 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
311 WriteLine ("return new " + main.ReaderClassName + " ();");
315 WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {");
316 WriteLine ("return new " + main.WriterClassName + " ();");
320 WriteLineInd ("public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {");
321 WriteLine ("return true;");
327 // Write a serializer for each imported map
329 foreach (GenerationResult res in generatedMaps)
331 res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
333 WriteLine (access_mod + " sealed class " + res.SerializerClassName + " : " + baseSerializerName);
335 WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
336 WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
340 WriteLineInd ("protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {");
341 WriteLine ("return ((" + res.ReaderClassName + ")reader)." + res.ReadMethodName + "();");
348 WriteLine (access_mod + " class " + main.ImplementationClassName + " : System.Xml.Serialization.XmlSerializerImplementation");
351 WriteLine ("System.Collections.Hashtable readMethods = null;");
352 WriteLine ("System.Collections.Hashtable writeMethods = null;");
353 WriteLine ("System.Collections.Hashtable typedSerializers = null;");
356 WriteLineInd ("public override System.Xml.Serialization.XmlSerializationReader Reader {");
357 WriteLineInd ("get {");
358 WriteLine ("return new " + main.ReaderClassName + "();");
363 WriteLineInd ("public override System.Xml.Serialization.XmlSerializationWriter Writer {");
364 WriteLineInd ("get {");
365 WriteLine ("return new " + main.WriterClassName + "();");
370 WriteLineInd ("public override System.Collections.Hashtable ReadMethods {");
371 WriteLineInd ("get {");
372 WriteLineInd ("lock (this) {");
373 WriteLineInd ("if (readMethods == null) {");
374 WriteLine ("readMethods = new System.Collections.Hashtable ();");
375 foreach (GenerationResult res in generatedMaps)
376 WriteLine ("readMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.ReadMethodName + "\");");
378 WriteLine ("return readMethods;");
384 WriteLineInd ("public override System.Collections.Hashtable WriteMethods {");
385 WriteLineInd ("get {");
386 WriteLineInd ("lock (this) {");
387 WriteLineInd ("if (writeMethods == null) {");
388 WriteLine ("writeMethods = new System.Collections.Hashtable ();");
389 foreach (GenerationResult res in generatedMaps)
390 WriteLine ("writeMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.WriteMethodName + "\");");
392 WriteLine ("return writeMethods;");
398 WriteLineInd ("public override System.Collections.Hashtable TypedSerializers {");
399 WriteLineInd ("get {");
400 WriteLineInd ("lock (this) {");
401 WriteLineInd ("if (typedSerializers == null) {");
402 WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
403 foreach (GenerationResult res in generatedMaps)
404 WriteLine ("typedSerializers.Add (@\"" + res.Mapping.GetKey () + "\", new " + res.SerializerClassName + "());");
406 WriteLine ("return typedSerializers;");
412 WriteLine ("public override XmlSerializer GetSerializer (Type type)");
414 WriteLine ("switch (type.FullName) {");
415 foreach (GenerationResult res in generatedMaps) {
416 if (res.Mapping is XmlTypeMapping) {
417 WriteLineInd ("case \"" + ((XmlTypeMapping) res.Mapping).TypeData.CSharpFullName + "\":");
418 WriteLine ("return (XmlSerializer) TypedSerializers [\"" + res.Mapping.GetKey () + "\"];");
423 WriteLine ("return base.GetSerializer (type);");
427 WriteLineInd ("public override bool CanSerialize (System.Type type) {");
428 foreach (GenerationResult res in generatedMaps) {
429 if (res.Mapping is XmlTypeMapping)
430 WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.CSharpFullName + ")) return true;");
432 WriteLine ("return false;");
441 //*******************************************************
445 public void GenerateWriter (string writerClassName, ArrayList maps)
447 _mapsToGenerate = new ArrayList ();
451 if (_config == null || !_config.GenerateAsInternal)
452 WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
454 WriteLine ("internal class " + writerClassName + " : XmlSerializationWriter");
456 WriteLine ("const string xmlNamespace = \"http://www.w3.org/2000/xmlns/\";");
458 for (int n=0; n<maps.Count; n++)
460 GenerationResult res = (GenerationResult) maps [n];
461 _typeMap = res.Mapping;
462 _format = _typeMap.Format;
465 GenerateWriteRoot ();
468 for (int n=0; n<_mapsToGenerate.Count; n++)
470 XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
471 GenerateWriteObject (map);
472 if (map.TypeData.SchemaType == SchemaTypes.Enum)
473 GenerateGetXmlEnumValue (map);
476 GenerateWriteInitCallbacks ();
477 UpdateGeneratedTypes (_mapsToGenerate);
482 void GenerateWriteRoot ()
484 WriteLine ("public void " +_result.WriteMethodName + " (object o)");
486 WriteLine ("WriteStartDocument ();");
488 if (_typeMap is XmlTypeMapping)
490 WriteLine (GetRootTypeName () + " ob = (" + GetRootTypeName () + ") o;");
491 XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
492 if (mp.TypeData.SchemaType == SchemaTypes.Class || mp.TypeData.SchemaType == SchemaTypes.Array)
493 WriteLine ("TopLevelElement ();");
495 if (_format == SerializationFormat.Literal) {
496 WriteLine (GetWriteObjectName (mp) + " (ob, " + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", true, false, true);");
499 RegisterReferencingMap (mp);
500 WriteLine ("WritePotentiallyReferencingElement (" + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", ob, " + GetTypeOf(mp.TypeData) + ", true, false);");
503 else if (_typeMap is XmlMembersMapping) {
504 WriteLine ("object[] pars = (object[]) o;");
505 GenerateWriteMessage ((XmlMembersMapping) _typeMap);
508 throw new InvalidOperationException ("Unknown type map");
510 if (_format == SerializationFormat.Encoded)
511 WriteLine ("WriteReferencedElements ();");
517 void GenerateWriteMessage (XmlMembersMapping membersMap)
519 if (membersMap.HasWrapperElement) {
520 WriteLine ("TopLevelElement ();");
521 WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));");
523 /* WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)");
524 WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);");
527 WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)");
528 WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);");
533 GenerateWriteObjectElement (membersMap, "pars", true);
535 if (membersMap.HasWrapperElement)
536 WriteLine ("WriteEndElement();");
539 void GenerateGetXmlEnumValue (XmlTypeMapping map)
541 EnumMap emap = (EnumMap) map.ObjectMap;
543 string xmlNamesArray = null;
544 string valuesArray = null;
547 // create static string[] holding XML names of enum constants
548 xmlNamesArray = GetUniqueName ("gxe", map, "_xmlNames" + map.XmlType);
549 Write ("static readonly string[] " + xmlNamesArray + " = { ");
550 for (int i = 0; i < emap.XmlNames.Length; i++) {
554 _writer.Write (emap.XmlNames[i]);
555 _writer.Write ('\"');
557 _writer.WriteLine (" };");
559 // create const long[] holding values of enum constants
560 valuesArray = GetUniqueName ("gve", map, "_values" + map.XmlType);
561 Write ("static readonly long[] " + valuesArray + " = { ");
562 for (int i = 0; i < emap.Values.Length; i++) {
565 _writer.Write (emap.Values[i].ToString (CultureInfo.InvariantCulture));
568 _writer.WriteLine (" };");
569 WriteLine (string.Empty);
572 WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeData.CSharpFullName + " val)");
576 WriteLineInd ("switch (val) {");
577 for (int i = 0; i < emap.EnumNames.Length; i++)
578 WriteLine ("case " + map.TypeData.CSharpFullName + "." + emap.EnumNames[i] + ": return " + GetLiteral (emap.XmlNames[i]) + ";");
581 WriteLineInd ("default:");
582 // FromEnum actually covers this case too, but we save some cycles here
583 WriteLine ("if (val.ToString () == \"0\") return string.Empty;");
584 Write ("return FromEnum ((long) val, " + xmlNamesArray + ", " + valuesArray);
586 _writer.Write (", typeof (");
587 _writer.Write (map.TypeData.CSharpFullName);
588 _writer.Write (").FullName");
590 _writer.Write (')'); // close FromEnum method call
591 WriteUni (";"); // end statement
594 WriteLine ("default: throw CreateInvalidEnumValueException ((long) val, typeof (" + map.TypeData.CSharpFullName + ").FullName);");
596 WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
606 void GenerateWriteObject (XmlTypeMapping typeMap)
608 WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeData.CSharpFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
613 SetHookVar ("$TYPE", typeMap.TypeData.CSharpName);
614 SetHookVar ("$FULLTYPE", typeMap.TypeData.CSharpFullName);
615 SetHookVar ("$OBJECT", "ob");
616 SetHookVar ("$ELEMENT", "element");
617 SetHookVar ("$NAMESPACE", "namesp");
618 SetHookVar ("$NULLABLE", "isNullable");
620 if (GenerateWriteHook (HookType.type, typeMap.TypeData.Type))
628 if (!typeMap.TypeData.IsValueType)
630 WriteLine ("if (((object)ob) == null)");
632 WriteLineInd ("if (isNullable)");
634 if (_format == SerializationFormat.Literal)
635 WriteLine ("WriteNullTagLiteral(element, namesp);");
637 WriteLine ("WriteNullTagEncoded (element, namesp);");
639 WriteLineUni ("return;");
644 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
646 if (_format == SerializationFormat.Literal)
647 WriteLine ("WriteElementLiteral (ob, \"\", \"\", true, false);");
649 WriteLine ("WriteElementEncoded (ob, \"\", \"\", true, false);");
658 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlSerializable)
660 WriteLine ("WriteSerializable (ob, element, namesp, isNullable);");
669 ArrayList types = typeMap.DerivedTypes;
671 WriteLine ("System.Type type = ob.GetType ();");
672 WriteLine ("if (type == typeof(" + typeMap.TypeData.CSharpFullName + "))");
675 for (int n=0; n<types.Count; n++)
677 XmlTypeMapping map = (XmlTypeMapping)types[n];
679 WriteLineInd ("else if (type == typeof(" + map.TypeData.CSharpFullName + ")) { ");
680 WriteLine (GetWriteObjectName (map) + "((" + map.TypeData.CSharpFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
681 WriteLine ("return;");
685 if (typeMap.TypeData.Type == typeof (object)) {
686 WriteLineInd ("else {");
687 WriteLine ("WriteTypedPrimitive (element, namesp, ob, true);");
688 WriteLine ("return;");
693 WriteLineInd ("else {");
694 WriteLine ("throw CreateUnknownTypeException (ob);");
698 WriteLineInd ("if (writeWrappingElem) {");
699 if (_format == SerializationFormat.Encoded) WriteLine ("needType = true;");
700 WriteLine ("WriteStartElement (element, namesp, ob);");
704 WriteLine ("if (needType) WriteXsiType(" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.XmlTypeNamespace) + ");");
707 switch (typeMap.TypeData.SchemaType)
709 case SchemaTypes.Class: GenerateWriteObjectElement (typeMap, "ob", false); break;
710 case SchemaTypes.Array: GenerateWriteListElement (typeMap, "ob"); break;
711 case SchemaTypes.Primitive: GenerateWritePrimitiveElement (typeMap, "ob"); break;
712 case SchemaTypes.Enum: GenerateWriteEnumElement (typeMap, "ob"); break;
715 WriteLine ("if (writeWrappingElem) WriteEndElement (ob);");
724 void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
726 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
727 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
729 ClassMap map = (ClassMap)xmlMap.ObjectMap;
730 if (!GenerateWriteHook (HookType.attributes, xmlMapType))
732 if (map.NamespaceDeclarations != null) {
733 WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
737 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
738 if (anyAttrMember != null)
740 if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
742 string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
743 if (cond != null) WriteLineInd ("if (" + cond + ") {");
745 string tmpVar = GetObTempVar ();
746 WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
747 WriteLineInd ("if (" + tmpVar + " != null) {");
749 string tmpVar2 = GetObTempVar ();
750 WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
751 WriteLineInd ("if (" + tmpVar2 + ".NamespaceURI != xmlNamespace)");
752 WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
757 if (cond != null) WriteLineUni ("}");
763 ICollection attributes = map.AttributeMembers;
764 if (attributes != null)
766 foreach (XmlTypeMapMemberAttribute attr in attributes)
768 if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
770 string val = GenerateGetMemberValue (attr, ob, isValueList);
771 string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
773 if (cond != null) WriteLineInd ("if (" + cond + ") {");
775 string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val);
776 WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
778 if (cond != null) WriteLineUni ("}");
786 if (!GenerateWriteHook (HookType.elements, xmlMapType))
788 ICollection members = map.ElementMembers;
791 foreach (XmlTypeMapMemberElement member in members)
793 if (GenerateWriteMemberHook (xmlMapType, member)) continue;
795 string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
796 if (cond != null) WriteLineInd ("if (" + cond + ") {");
798 string memberValue = GenerateGetMemberValue (member, ob, isValueList);
799 Type memType = member.GetType();
801 if (memType == typeof(XmlTypeMapMemberList))
803 GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
805 else if (memType == typeof(XmlTypeMapMemberFlatList))
807 WriteLineInd ("if (" + memberValue + " != null) {");
808 GenerateWriteListContent (ob, member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
811 else if (memType == typeof(XmlTypeMapMemberAnyElement))
813 WriteLineInd ("if (" + memberValue + " != null) {");
814 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
817 else if (memType == typeof(XmlTypeMapMemberAnyElement))
819 WriteLineInd ("if (" + memberValue + " != null) {");
820 GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
823 else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
827 else if (memType == typeof(XmlTypeMapMemberElement))
829 if (member.ElementInfo.Count == 1) {
830 GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
832 else if (member.ChoiceMember != null)
834 string choiceValue = ob + ".@" + member.ChoiceMember;
835 foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
836 WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
837 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
843 // WriteLineInd ("if (" + memberValue + " == null) {");
844 // GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
845 // WriteLineUni ("}");
848 foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
850 WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.CSharpFullName + ") {");
851 GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
858 throw new InvalidOperationException ("Unknown member type");
870 void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
872 switch (elem.TypeData.SchemaType)
874 case SchemaTypes.XmlNode:
875 string elemName = elem.WrappedElement ? elem.ElementName : "";
876 if (_format == SerializationFormat.Literal)
877 WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
879 WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
882 case SchemaTypes.Enum:
883 case SchemaTypes.Primitive:
884 if (_format == SerializationFormat.Literal)
885 GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
887 GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
890 case SchemaTypes.Array:
891 WriteLineInd ("if (" + memberValue + " != null) {");
893 if (elem.MappedType.MultiReferenceType) {
894 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
895 RegisterReferencingMap (elem.MappedType);
898 WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
899 GenerateWriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
900 WriteMetCall ("WriteEndElement", memberValue);
904 if (elem.IsNullable) {
905 WriteLineInd ("else");
906 if (_format == SerializationFormat.Literal)
907 WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
909 WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
915 case SchemaTypes.Class:
916 if (elem.MappedType.MultiReferenceType) {
917 RegisterReferencingMap (elem.MappedType);
918 if (elem.MappedType.TypeData.Type == typeof(object))
919 WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
921 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
924 WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
927 case SchemaTypes.XmlSerializable:
928 WriteMetCall ("WriteSerializable", memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
932 throw new NotSupportedException ("Invalid value type");
936 void GenerateWriteListElement (XmlTypeMapping typeMap, string ob)
938 if (_format == SerializationFormat.Encoded)
941 string itemCount = GenerateGetListCount (typeMap.TypeData, ob);
942 GenerateGetArrayType ((ListMap) typeMap.ObjectMap, itemCount, out n, out ns);
945 if (ns != string.Empty)
946 arrayType = "FromXmlQualifiedName (new XmlQualifiedName(" + n + "," + ns + "))";
948 arrayType = GetLiteral (n);
950 WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
952 GenerateWriteListContent (null, typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
955 void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
957 bool singleElement = (member.TypeData.Type == typeof (XmlElement));
963 var = GetObTempVar ();
964 WriteLineInd ("foreach (XmlNode " + var + " in " + memberValue + ") {");
967 string elem = GetObTempVar ();
968 WriteLine ("XmlNode " + elem + " = " + var + ";");
969 WriteLine ("if (" + elem + " is XmlElement) {");
971 if (!member.IsDefaultAny) {
972 for (int n=0; n<member.ElementInfo.Count; n++) {
973 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)member.ElementInfo[n];
974 string txt = "(" + elem + ".Name == " + GetLiteral(info.ElementName) + " && " + elem + ".NamespaceURI == " + GetLiteral(info.Namespace) + ")";
975 if (n == member.ElementInfo.Count-1) txt += ") {";
976 if (n == 0) WriteLineInd ("if (" + txt);
977 else WriteLine ("|| " + txt);
981 WriteLine ("else " + elem + ".WriteTo (Writer);");
983 if (_format == SerializationFormat.Literal)
984 WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
986 WriteLine ("WriteElementEncoded (" + elem + ", \"\", \"\", false, true);");
988 if (!member.IsDefaultAny) {
990 WriteLineInd ("else");
991 WriteLine ("throw CreateUnknownAnyElementException (" + elem + ".Name, " + elem + ".NamespaceURI);");
999 void GenerateWritePrimitiveElement (XmlTypeMapping typeMap, string ob)
1001 string strVal = GenerateGetStringValue (typeMap, typeMap.TypeData, ob);
1002 WriteLine ("Writer.WriteString (" + strVal + ");");
1005 void GenerateWriteEnumElement (XmlTypeMapping typeMap, string ob)
1007 string strVal = GenerateGetEnumXmlValue (typeMap, ob);
1008 WriteLine ("Writer.WriteString (" + strVal + ");");
1011 string GenerateGetStringValue (XmlTypeMapping typeMap, TypeData type, string value)
1013 if (type.SchemaType == SchemaTypes.Array) {
1014 string str = GetStrTempVar ();
1015 WriteLine ("string " + str + " = null;");
1016 WriteLineInd ("if (" + value + " != null) {");
1017 string res = GenerateWriteListContent (null, typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
1018 WriteLine (str + " = " + res + ".ToString ().Trim ();");
1022 else if (type.SchemaType == SchemaTypes.Enum) {
1023 return GenerateGetEnumXmlValue (typeMap, value);
1025 else if (type.Type == typeof (XmlQualifiedName))
1026 return "FromXmlQualifiedName (" + value + ")";
1027 else if (value == null)
1030 return XmlCustomFormatter.GenerateToXmlString (type, value);
1033 string GenerateGetEnumXmlValue (XmlTypeMapping typeMap, string ob)
1035 return GetGetEnumValueName (typeMap) + " (" + ob + ")";
1038 string GenerateGetListCount (TypeData listType, string ob)
1040 if (listType.Type.IsArray)
1046 void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns)
1049 if (itemCount != "") arrayDim = "";
1050 else arrayDim = "[]";
1052 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0];
1053 if (info.TypeData.SchemaType == SchemaTypes.Array)
1056 GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns);
1057 localName = nm + arrayDim;
1061 if (info.MappedType != null)
1063 localName = info.MappedType.XmlType + arrayDim;
1064 ns = info.MappedType.Namespace;
1068 localName = info.TypeData.XmlType + arrayDim;
1069 ns = info.DataTypeNamespace;
1072 if (itemCount != "") {
1073 localName = "\"" + localName + "[\" + " + itemCount + " + \"]\"";
1074 ns = GetLiteral (ns);
1078 string GenerateWriteListContent (string container, TypeData listType, ListMap map, string ob, bool writeToString)
1080 string targetString = null;
1084 targetString = GetStrTempVar ();
1085 WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();");
1088 if (listType.Type.IsArray)
1090 string itemVar = GetNumTempVar ();
1091 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
1092 GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
1095 else if (typeof(ICollection).IsAssignableFrom (listType.Type))
1097 string itemVar = GetNumTempVar ();
1098 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
1099 GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
1102 else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
1104 string itemVar = GetObTempVar ();
1105 WriteLineInd ("foreach (" + listType.ListItemTypeData.CSharpFullName + " " + itemVar + " in " + ob + ") {");
1106 GenerateListLoop (container, map, itemVar, null, listType.ListItemTypeData, targetString);
1110 throw new Exception ("Unsupported collection type");
1112 return targetString;
1115 void GenerateListLoop (string container, ListMap map, string item, string index, TypeData itemTypeData, string targetString)
1117 bool multichoice = (map.ItemInfo.Count > 1);
1119 if (map.ChoiceMember != null && container != null && index != null) {
1120 WriteLineInd ("if ((" + container + ".@" + map.ChoiceMember + " == null) || (" + index + " >= " + container + ".@" + map.ChoiceMember + ".Length))");
1121 WriteLine ("throw CreateInvalidChoiceIdentifierValueException (" + container + ".GetType().ToString(), \"" + map.ChoiceMember + "\");");
1126 WriteLine ("if (((object)" + item + ") == null) { }");
1128 foreach (XmlTypeMapElementInfo info in map.ItemInfo)
1130 if (map.ChoiceMember != null && multichoice)
1131 WriteLineInd ("else if (" + container + ".@" + map.ChoiceMember + "[" + index + "] == " + GetLiteral (info.ChoiceValue) + ") {");
1132 else if (multichoice)
1133 WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.CSharpFullName + ")) {");
1135 if (targetString == null)
1136 GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
1139 string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item));
1140 WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");");
1148 WriteLine ("else throw CreateUnknownTypeException (" + item + ");");
1151 void GenerateWritePrimitiveValueLiteral (string memberValue, string name, string ns, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1154 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1155 WriteMetCall ("WriteValue", strVal);
1157 else if (isNullable) {
1158 if (typeData.Type == typeof(XmlQualifiedName))
1159 WriteMetCall ("WriteNullableQualifiedNameLiteral", GetLiteral(name), GetLiteral(ns), memberValue);
1161 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1162 WriteMetCall ("WriteNullableStringLiteral", GetLiteral(name), GetLiteral(ns), strVal);
1166 if (typeData.Type == typeof(XmlQualifiedName))
1167 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue);
1169 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1170 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal);
1175 void GenerateWritePrimitiveValueEncoded (string memberValue, string name, string ns, XmlQualifiedName xsiType, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1178 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1179 WriteMetCall ("WriteValue", strVal);
1181 else if (isNullable) {
1182 if (typeData.Type == typeof(XmlQualifiedName))
1183 WriteMetCall ("WriteNullableQualifiedNameEncoded", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1185 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1186 WriteMetCall ("WriteNullableStringEncoded", GetLiteral(name), GetLiteral(ns), strVal, GetLiteral(xsiType));
1190 if (typeData.Type == typeof(XmlQualifiedName))
1191 WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1193 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1194 WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal, GetLiteral(xsiType));
1199 string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
1201 if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.GlobalIndex + "]");
1202 else return ob + ".@" + member.Name;
1205 string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
1208 return ob + ".Length > " + member.GlobalIndex;
1210 else if (member.DefaultValue != System.DBNull.Value) {
1211 string mem = ob + ".@" + member.Name;
1212 if (member.DefaultValue == null)
1213 return mem + " != null";
1214 else if (member.TypeData.SchemaType == SchemaTypes.Enum)
1215 return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
1217 return mem + " != " + GetLiteral (member.DefaultValue);
1219 else if (member.IsOptionalValueType)
1220 return ob + ".@" + member.Name + "Specified";
1224 void GenerateWriteInitCallbacks ()
1226 WriteLine ("protected override void InitCallbacks ()");
1229 if (_format == SerializationFormat.Encoded)
1231 foreach (XmlMapping xmap in _mapsToGenerate) {
1232 XmlTypeMapping map = xmap as XmlTypeMapping;
1234 WriteMetCall ("AddWriteCallback", GetTypeOf(map.TypeData), GetLiteral(map.XmlType), GetLiteral(map.Namespace), "new XmlSerializationWriteCallback (" + GetWriteObjectCallbackName (map) + ")");
1241 if (_format == SerializationFormat.Encoded)
1243 foreach (XmlTypeMapping xmap in _mapsToGenerate) {
1244 XmlTypeMapping map = xmap as XmlTypeMapping;
1245 if (map == null) continue;
1246 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1247 WriteWriteEnumCallback (map);
1249 WriteWriteObjectCallback (map);
1254 void WriteWriteEnumCallback (XmlTypeMapping map)
1256 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1258 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "true", "false");
1263 void WriteWriteObjectCallback (XmlTypeMapping map)
1265 WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1267 WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "false", "false");
1274 #region Reader Generation
1276 //*******************************************************
1277 // Reader generation
1280 public void GenerateReader (string readerClassName, ArrayList maps)
1282 if (_config == null || !_config.GenerateAsInternal)
1283 WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
1285 WriteLine ("internal class " + readerClassName + " : XmlSerializationReader");
1288 _mapsToGenerate = new ArrayList ();
1289 _fixupCallbacks = new ArrayList ();
1292 for (int n=0; n<maps.Count; n++)
1294 GenerationResult res = (GenerationResult) maps [n];
1295 _typeMap = res.Mapping;
1296 _format = _typeMap.Format;
1299 GenerateReadRoot ();
1302 for (int n=0; n<_mapsToGenerate.Count; n++)
1304 XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
1305 if (map == null) continue;
1307 GenerateReadObject (map);
1308 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1309 GenerateGetEnumValue (map);
1312 GenerateReadInitCallbacks ();
1314 if (_format == SerializationFormat.Encoded)
1316 GenerateFixupCallbacks ();
1317 GenerateFillerCallbacks ();
1321 UpdateGeneratedTypes (_mapsToGenerate);
1324 void GenerateReadRoot ()
1326 WriteLine ("public object " + _result.ReadMethodName + " ()");
1328 WriteLine ("Reader.MoveToContent();");
1330 if (_typeMap is XmlTypeMapping)
1332 XmlTypeMapping typeMap = (XmlTypeMapping) _typeMap;
1334 if (_format == SerializationFormat.Literal)
1336 if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode) {
1337 if (typeMap.TypeData.Type == typeof (XmlDocument))
1338 WriteLine ("return ReadXmlDocument (false);");
1340 WriteLine ("return ReadXmlNode (false);");
1342 WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
1343 WriteLine ("throw CreateUnknownNodeException();");
1346 WriteLine ("return " + GetReadObjectCall (typeMap, GetLiteral(typeMap.IsNullable), "true") + ";");
1351 WriteLine ("object ob = null;");
1352 WriteLine ("Reader.MoveToContent();");
1353 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1355 WriteLineInd ("if (Reader.LocalName == " + GetLiteral(typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
1356 WriteLine ("ob = ReadReferencedElement();");
1358 WriteLineInd ("else ");
1359 WriteLine ("throw CreateUnknownNodeException();");
1362 WriteLineInd ("else ");
1363 WriteLine ("UnknownNode(null);");
1366 WriteLine ("ReadReferencedElements();");
1367 WriteLine ("return ob;");
1368 RegisterReferencingMap (typeMap);
1372 WriteLine ("return " + GenerateReadMessage ((XmlMembersMapping)_typeMap) + ";");
1379 string GenerateReadMessage (XmlMembersMapping typeMap)
1381 WriteLine ("object[] parameters = new object[" + typeMap.Count + "];");
1384 if (typeMap.HasWrapperElement)
1386 if (_format == SerializationFormat.Encoded)
1388 WriteLine ("while (Reader.NodeType == System.Xml.XmlNodeType.Element)");
1390 WriteLine ("string root = Reader.GetAttribute (\"root\", " + GetLiteral(XmlSerializer.EncodingNamespace) + ");");
1391 WriteLine ("if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;");
1392 WriteLine ("ReadReferencedElement ();");
1393 WriteLine ("Reader.MoveToContent ();");
1396 WriteLine ("if (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1398 WriteLineInd ("if (Reader.IsEmptyElement) {");
1399 WriteLine ("Reader.Skip();");
1401 WriteLineInd ("else {");
1402 WriteLine ("Reader.ReadStartElement();");
1403 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1404 WriteLine ("ReadEndElement();");
1407 WriteLine ("Reader.MoveToContent();");
1412 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1414 WriteLine ("if (Reader.IsStartElement(" + GetLiteral(typeMap.ElementName) + ", " + GetLiteral(typeMap.Namespace) + "))");
1416 WriteLine ("if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }");
1417 WriteLine ("Reader.ReadStartElement();");
1418 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1419 WriteLine ("ReadEndElement();");
1420 WriteLine ("break;");
1422 WriteLineInd ("else ");
1423 WriteLine ("UnknownNode(null);");
1426 WriteLine ("Reader.MoveToContent();");
1431 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, _format == SerializationFormat.Encoded);
1433 if (_format == SerializationFormat.Encoded)
1434 WriteLine ("ReadReferencedElements();");
1436 return "parameters";
1439 void GenerateReadObject (XmlTypeMapping typeMap)
1442 if (_format == SerializationFormat.Literal) {
1443 WriteLine ("public " + typeMap.TypeData.CSharpFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
1444 isNullable = "isNullable";
1447 WriteLine ("public object " + GetReadObjectName (typeMap) + " ()");
1448 isNullable = "true";
1455 SetHookVar ("$TYPE", typeMap.TypeData.CSharpName);
1456 SetHookVar ("$FULLTYPE", typeMap.TypeData.CSharpFullName);
1457 SetHookVar ("$NULLABLE", "isNullable");
1459 switch (typeMap.TypeData.SchemaType)
1461 case SchemaTypes.Class: GenerateReadClassInstance (typeMap, isNullable, "checkType"); break;
1462 case SchemaTypes.Array:
1463 string list = GenerateReadListElement (typeMap, null, isNullable, true);
1465 WriteLine ("return " + list + ";");
1467 case SchemaTypes.XmlNode: GenerateReadXmlNodeElement (typeMap, isNullable); break;
1468 case SchemaTypes.Primitive: GenerateReadPrimitiveElement (typeMap, isNullable); break;
1469 case SchemaTypes.Enum: GenerateReadEnumElement (typeMap, isNullable); break;
1470 case SchemaTypes.XmlSerializable: GenerateReadXmlSerializableElement (typeMap, isNullable); break;
1471 default: throw new Exception ("Unsupported map type");
1479 void GenerateReadClassInstance (XmlTypeMapping typeMap, string isNullable, string checkType)
1481 SetHookVar ("$OBJECT", "ob");
1482 if (!typeMap.TypeData.IsValueType)
1484 WriteLine (typeMap.TypeData.CSharpFullName + " ob = null;");
1486 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1487 WriteLine ("return ob;");
1491 if (_format == SerializationFormat.Literal) {
1492 WriteLine ("if (" + isNullable + " && ReadNull()) return null;");
1494 WriteLine ("if (checkType) ");
1498 WriteLine ("if (ReadNull()) return null;");
1504 WriteLine (typeMap.TypeData.CSharpFullName + " ob = new " + typeMap.TypeData.CSharpFullName + " ();");
1506 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1507 WriteLine ("return ob;");
1512 WriteLine ("System.Xml.XmlQualifiedName t = GetXsiType();");
1513 WriteLine ("if (t == null)");
1514 if (typeMap.TypeData.Type != typeof(object))
1517 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (new System.Xml.XmlQualifiedName(\"anyType\", System.Xml.Schema.XmlSchema.Namespace))") + ";");
1519 foreach (XmlTypeMapping realMap in typeMap.DerivedTypes)
1521 WriteLineInd ("else if (t.Name == " + GetLiteral (realMap.XmlType) + " && t.Namespace == " + GetLiteral (realMap.XmlTypeNamespace) + ")");
1522 WriteLine ("return " + GetReadObjectCall(realMap, isNullable, checkType) + ";");
1526 WriteLine ("else if (t.Name != " + GetLiteral (typeMap.XmlType) + " || t.Namespace != " + GetLiteral (typeMap.XmlTypeNamespace) + ")");
1527 if (typeMap.TypeData.Type == typeof(object))
1528 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
1530 WriteLine ("\tthrow CreateUnknownTypeException(t);");
1532 if (!typeMap.TypeData.IsValueType)
1534 if (_format == SerializationFormat.Literal)
1537 if (typeMap.TypeData.Type.IsAbstract) {
1539 WriteLine ("return ob;");
1544 WriteLine ("ob = new " + typeMap.TypeData.CSharpFullName + " ();");
1549 WriteLine ("Reader.MoveToElement();");
1552 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "ob", false, false);
1557 WriteLine ("return ob;");
1560 void GenerateReadMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, bool readByOrder)
1562 XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
1563 Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
1565 // Load the default value of members
1566 if (map.MembersWithDefault != null)
1568 ArrayList members = map.MembersWithDefault;
1569 for (int n=0; n<members.Count; n++) {
1570 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
1571 GenerateSetMemberValueFromAttr (mem, ob, GetLiteral (mem.DefaultValue), isValueList);
1575 // A value list cannot have attributes
1578 if (!isValueList && !GenerateReadHook (HookType.attributes, xmlMapType))
1582 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
1584 if (anyAttrMember != null)
1586 WriteLine ("int anyAttributeIndex = 0;");
1587 WriteLine (anyAttrMember.TypeData.CSharpFullName + " anyAttributeArray = null;");
1590 WriteLine ("while (Reader.MoveToNextAttribute())");
1593 if (map.AttributeMembers != null) {
1594 foreach (XmlTypeMapMemberAttribute at in map.AttributeMembers)
1596 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (at.AttributeName) + " && Reader.NamespaceURI == " + GetLiteral (at.Namespace) + ") {");
1597 if (!GenerateReadMemberHook (xmlMapType, at)) {
1598 GenerateSetMemberValue (at, ob, GenerateGetValueFromXmlString ("Reader.Value", at.TypeData, at.MappedType), isValueList);
1605 WriteLineInd ((first?"":"else ") + "if (IsXmlnsAttribute (Reader.Name)) {");
1607 // If the map has NamespaceDeclarations,
1608 // then store this xmlns to the given member.
1609 // If the instance doesn't exist, then create.
1611 if (map.NamespaceDeclarations != null) {
1612 if (!GenerateReadMemberHook (xmlMapType, map.NamespaceDeclarations)) {
1613 string nss = ob + ".@" + map.NamespaceDeclarations.Name;
1614 WriteLine ("if (" + nss + " == null) " + nss + " = new XmlSerializerNamespaces ();");
1615 WriteLineInd ("if (Reader.Prefix == \"xmlns\")");
1616 WriteLine (nss + ".Add (Reader.LocalName, Reader.Value);");
1618 WriteLineInd ("else");
1619 WriteLine (nss + ".Add (\"\", Reader.Value);");
1626 WriteLineInd ("else {");
1628 if (anyAttrMember != null)
1630 if (!GenerateReadArrayMemberHook (xmlMapType, anyAttrMember, "anyAttributeIndex")) {
1631 WriteLine ("System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);");
1632 if (typeof(System.Xml.Schema.XmlSchemaAnnotated).IsAssignableFrom (xmlMapType))
1633 WriteLine ("ParseWsdlArrayType (attr);");
1634 GenerateAddListValue (anyAttrMember.TypeData, "anyAttributeArray", "anyAttributeIndex", GetCast (anyAttrMember.TypeData.ListItemTypeData, "attr"), true);
1637 WriteLine ("anyAttributeIndex++;");
1640 if (!GenerateReadHook (HookType.unknownAttribute, xmlMapType)) {
1641 WriteLine ("UnknownNode (" + ob + ");");
1649 if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
1652 WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.CSharpFullName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
1653 GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
1662 WriteLine ("Reader.MoveToElement();");
1663 WriteLineInd ("if (Reader.IsEmptyElement) {");
1664 WriteLine ("Reader.Skip ();");
1665 GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
1666 WriteLine ("return " + ob + ";");
1670 WriteLine ("Reader.ReadStartElement();");
1675 WriteLine("Reader.MoveToContent();");
1678 if (!GenerateReadHook (HookType.elements, xmlMapType))
1680 string[] readFlag = null;
1681 if (map.ElementMembers != null && !readByOrder)
1683 string readFlagsVars = "bool ";
1684 readFlag = new string[map.ElementMembers.Count];
1685 for (int n=0; n<map.ElementMembers.Count; n++) {
1686 readFlag[n] = GetBoolTempVar ();
1687 if (n > 0) readFlagsVars += ", ";
1688 readFlagsVars += readFlag[n] + "=false";
1690 if (map.ElementMembers.Count > 0) WriteLine (readFlagsVars + ";");
1694 string[] indexes = null;
1695 string[] flatLists = null;
1696 string[] flatListsChoices = null;
1698 if (map.FlatLists != null)
1700 indexes = new string[map.FlatLists.Count];
1701 flatLists = new string[map.FlatLists.Count];
1703 string code = "int ";
1704 for (int n=0; n<map.FlatLists.Count; n++)
1706 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.FlatLists[n];
1707 indexes[n] = GetNumTempVar ();
1708 if (n > 0) code += ", ";
1709 code += indexes[n] + "=0";
1710 if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
1711 flatLists[n] = GetObTempVar ();
1713 WriteLine (mem.TypeData.CSharpFullName + " " + flatLists[n] + ";");
1714 if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) {
1715 rval = GenerateGetMemberValue (mem, ob, isValueList);
1716 WriteLine (flatLists[n] + " = " + rval + ";");
1717 } else if (mem.TypeData.Type.IsArray) {
1718 rval = GenerateInitializeList (mem.TypeData);
1719 WriteLine (flatLists[n] + " = " + rval + ";");
1721 WriteLine (flatLists[n] + " = " + GenerateGetMemberValue (mem, ob, isValueList) + ";");
1722 WriteLineInd ("if (((object)" + flatLists[n] + ") == null) {");
1723 WriteLine (flatLists[n] + " = " + GenerateInitializeList (mem.TypeData) + ";");
1724 GenerateSetMemberValue (mem, ob, flatLists[n], isValueList);
1729 if (mem.ChoiceMember != null) {
1730 if (flatListsChoices == null)
1731 flatListsChoices = new string [map.FlatLists.Count];
1732 flatListsChoices[n] = GetObTempVar ();
1733 string rval = GenerateInitializeList (mem.ChoiceTypeData);
1734 WriteLine (mem.ChoiceTypeData.CSharpFullName + " " + flatListsChoices[n] + " = " + rval + ";");
1737 WriteLine (code + ";");
1741 if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
1743 _fixupCallbacks.Add (xmlMap);
1744 WriteLine ("Fixup fixup = new Fixup(" + ob + ", new XmlSerializationFixupCallback(" + GetFixupCallbackName (xmlMap) + "), " + map.ElementMembers.Count + ");");
1745 WriteLine ("AddFixup (fixup);");
1749 ArrayList infos = null;
1753 if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
1758 infos = new ArrayList ();
1759 infos.AddRange (map.AllElementInfos);
1760 maxInd = infos.Count;
1762 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
1764 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1769 for (int ind = 0; ind < maxInd; ind++)
1771 XmlTypeMapElementInfo info = readByOrder ? map.GetElement (ind) : (XmlTypeMapElementInfo) infos [ind];
1775 if (info.IsTextElement || info.IsUnnamedAnyElement) continue;
1776 string elemCond = first ? "" : "else ";
1778 if (!(info.Member.IsReturnValue && _format == SerializationFormat.Encoded)) {
1779 elemCond += "Reader.LocalName == " + GetLiteral (info.ElementName);
1780 if (!map.IgnoreMemberNamespace) elemCond += " && Reader.NamespaceURI == " + GetLiteral (info.Namespace);
1783 elemCond += "!" + readFlag[info.Member.Index] + ") {";
1784 WriteLineInd (elemCond);
1787 if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
1789 if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
1791 string list = GetObTempVar ();
1792 WriteLine ("object " + list + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1793 RegisterReferencingMap (info.MappedType);
1795 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // Already read
1796 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1797 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.CSharpFullName) + ");");
1799 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1802 if (!info.MappedType.TypeData.Type.IsArray)
1804 WriteLineInd ("else {");
1805 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1806 WriteLine (list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1808 WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1809 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1811 WriteLine ("AddFixup (new CollectionFixup (" + list + ", new XmlSerializationCollectionFixupCallback (" + GetFillListName(info.Member.TypeData) + "), fixup.Ids[" + info.Member.Index + "]));");
1812 WriteLine ("fixup.Ids[" + info.Member.Index + "] = null;"); // The member already has the value, no further fix needed.
1818 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1819 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) {
1820 GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
1821 } else if (info.MappedType.TypeData.Type.IsArray) {
1822 if (info.IsNullable)
1823 GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
1825 string list = GetObTempVar ();
1826 WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true) + ";");
1827 WriteLineInd ("if (((object)" + list + ") != null) {");
1828 GenerateSetMemberValue (info.Member, ob, list, isValueList);
1832 string list = GetObTempVar ();
1833 WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1834 WriteLineInd ("if (((object)" + list + ") == null) {");
1835 WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1836 GenerateSetMemberValue (info.Member, ob, list, isValueList);
1838 GenerateReadListElement (info.MappedType, list, GetLiteral(info.IsNullable), true);
1844 WriteLine (readFlag[info.Member.Index] + " = true;");
1846 else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
1848 XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
1849 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1850 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
1851 if (mem.ChoiceMember != null) {
1852 GenerateAddListValue (mem.ChoiceTypeData, flatListsChoices[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetLiteral (info.ChoiceValue), true);
1856 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1858 else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
1860 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
1861 if (mem.TypeData.IsListType) {
1862 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1863 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
1866 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1869 if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1870 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1875 else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
1878 WriteLine (readFlag[info.Member.Index] + " = true;");
1879 if (_format == SerializationFormat.Encoded)
1881 string val = GetObTempVar ();
1882 RegisterReferencingMap (info.MappedType);
1884 if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
1885 WriteLine ("object " + val + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1887 WriteLine ("object " + val + " = ReadReferencingElement (" + GetLiteral(info.Member.TypeData.XmlType) + ", " + GetLiteral(System.Xml.Schema.XmlSchema.Namespace) + ", out fixup.Ids[" + info.Member.Index + "]);");
1889 if (info.MultiReferenceType)
1890 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // already read
1892 WriteLineInd ("if (" + val + " != null) {"); // null value
1894 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,val), isValueList);
1897 else if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1898 if (info.ChoiceValue != null) {
1899 XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement) info.Member;
1900 WriteLine (ob + ".@" + imem.ChoiceMember + " = " + GetLiteral(info.ChoiceValue) + ";");
1902 GenerateSetMemberValue (info.Member, ob, GenerateReadObjectElement (info), isValueList);
1907 throw new InvalidOperationException ("Unknown member type");
1912 WriteLine ("Reader.MoveToContent();");
1918 if (!first) WriteLineInd ("else {");
1920 if (map.DefaultAnyElementMember != null)
1922 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
1923 if (mem.TypeData.IsListType) {
1924 if (!GenerateReadArrayMemberHook (xmlMapType, mem, indexes[mem.FlatArrayIndex])) {
1925 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
1928 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1930 else if (! GenerateReadMemberHook (xmlMapType, mem)) {
1931 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1936 if (!GenerateReadHook (HookType.unknownElement, xmlMapType)) {
1937 WriteLine ("UnknownNode (" + ob + ");");
1942 if (!first) WriteLineUni ("}");
1946 if (map.XmlTextCollector != null)
1948 WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)");
1951 if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
1953 XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
1954 XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
1955 TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
1957 if (!GenerateReadArrayMemberHook (xmlMapType, map.XmlTextCollector, indexes[mem.FlatArrayIndex])) {
1958 string val = (itype.Type == typeof (string)) ? "Reader.ReadString()" : GetReadXmlNode (itype, false);
1959 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], val, true);
1962 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1964 else if (!GenerateReadMemberHook (xmlMapType, map.XmlTextCollector))
1966 XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
1967 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
1968 if (info.TypeData.Type == typeof (string))
1969 GenerateSetMemberValue (mem, ob, "ReadString (" + GenerateGetMemberValue (mem, ob, isValueList) + ")", isValueList);
1971 GenerateSetMemberValue (mem, ob, GenerateGetValueFromXmlString ("Reader.ReadString()", info.TypeData, info.MappedType), isValueList);
1978 WriteLine ("\tUnknownNode(" + ob + ");");
1980 WriteLine ("Reader.MoveToContent();");
1984 WriteLine ("Reader.MoveToContent();");
1986 if (flatLists != null)
1989 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
1991 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
1993 string list = flatLists[mem.FlatArrayIndex];
1994 if (mem.TypeData.Type.IsArray)
1995 WriteLine (list + " = (" + mem.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
1996 if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList) && mem.TypeData.Type.IsArray)
1997 GenerateSetMemberValue (mem, ob, list, isValueList);
2001 if (flatListsChoices != null)
2004 foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
2006 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
2007 if (mem.ChoiceMember == null) continue;
2009 string list = flatListsChoices[mem.FlatArrayIndex];
2010 WriteLine (list + " = (" + mem.ChoiceTypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.ChoiceTypeData.Type.GetElementType()) + ", true);");
2011 WriteLine (ob + ".@" + mem.ChoiceMember + " = " + list + ";");
2015 GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
2023 WriteLine ("ReadEndElement();");
2027 void GenerateSetListMembersDefaults (XmlTypeMapping typeMap, ClassMap map, string ob, bool isValueList)
2029 if (map.ListMembers != null)
2031 ArrayList members = map.ListMembers;
2032 for (int n=0; n<members.Count; n++) {
2033 XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
2034 if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
2036 WriteLineInd ("if (" + GenerateGetMemberValue (mem, ob, isValueList) + " == null) {");
2037 GenerateSetMemberValue (mem, ob, GenerateInitializeList (mem.TypeData), isValueList);
2043 bool IsReadOnly (XmlTypeMapping map, XmlTypeMapMember member, TypeData memType, bool isValueList)
2045 if (isValueList) return !memType.HasPublicConstructor;
2046 else return member.IsReadOnly (map.TypeData.Type) || !memType.HasPublicConstructor;
2049 void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
2051 if (isValueList) WriteLine (ob + "[" + member.GlobalIndex + "] = " + value + ";");
2053 WriteLine (ob + ".@" + member.Name + " = " + value + ";");
2054 if (member.IsOptionalValueType)
2055 WriteLine (ob + "." + member.Name + "Specified = true;");
2059 void GenerateSetMemberValueFromAttr (XmlTypeMapMember member, string ob, string value, bool isValueList)
2061 // Enumeration values specified in custom attributes are stored as integer
2062 // values if the custom attribute property is of type object. So, it is
2063 // necessary to convert to the enum type before asigning the value to the field.
2065 if (member.TypeData.Type.IsEnum)
2066 value = GetCast (member.TypeData.Type, value);
2067 GenerateSetMemberValue (member, ob, value, isValueList);
2070 string GenerateReadObjectElement (XmlTypeMapElementInfo elem)
2072 switch (elem.TypeData.SchemaType)
2074 case SchemaTypes.XmlNode:
2075 return GetReadXmlNode (elem.TypeData, true);
2077 case SchemaTypes.Primitive:
2078 case SchemaTypes.Enum:
2079 return GenerateReadPrimitiveValue (elem);
2081 case SchemaTypes.Array:
2082 return GenerateReadListElement (elem.MappedType, null, GetLiteral(elem.IsNullable), true);
2084 case SchemaTypes.Class:
2085 return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
2087 case SchemaTypes.XmlSerializable:
2088 return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.CSharpFullName + " ())");
2091 throw new NotSupportedException ("Invalid value type");
2095 string GenerateReadPrimitiveValue (XmlTypeMapElementInfo elem)
2097 if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
2098 if (elem.IsNullable) return "ReadNullableQualifiedName ()";
2099 else return "ReadElementQualifiedName ()";
2101 else if (elem.IsNullable)
2102 return GenerateGetValueFromXmlString ("ReadNullableString ()", elem.TypeData, elem.MappedType);
2104 return GenerateGetValueFromXmlString ("Reader.ReadElementString ()", elem.TypeData, elem.MappedType);
2107 string GenerateGetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
2109 if (typeData.SchemaType == SchemaTypes.Array)
2110 return GenerateReadListString (typeMap, value);
2111 else if (typeData.SchemaType == SchemaTypes.Enum)
2112 return GenerateGetEnumValue (typeMap, value);
2113 else if (typeData.Type == typeof (XmlQualifiedName))
2114 return "ToXmlQualifiedName (" + value + ")";
2116 return XmlCustomFormatter.GenerateFromXmlString (typeData, value);
2119 string GenerateReadListElement (XmlTypeMapping typeMap, string list, string isNullable, bool canCreateInstance)
2121 Type listType = typeMap.TypeData.Type;
2122 ListMap listMap = (ListMap)typeMap.ObjectMap;
2123 bool doNullCheck = typeMap.TypeData.Type.IsArray;
2125 if (canCreateInstance && typeMap.TypeData.HasPublicConstructor)
2128 list = GetObTempVar ();
2129 WriteLine (typeMap.TypeData.CSharpFullName + " " + list + " = null;");
2131 WriteLineInd ("if (!ReadNull()) {");
2132 WriteLine (list + " = " + GenerateCreateList (listType) + ";");
2135 WriteLineInd ("if (!ReadNull()) {");
2141 WriteLineInd ("if (((object)" + list + ") == null)");
2142 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeData.CSharpFullName) + ");");
2144 doNullCheck = false;
2147 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeData.CSharpFullName) + ");");
2152 WriteLineInd ("if (Reader.IsEmptyElement) {");
2153 WriteLine ("Reader.Skip();");
2154 if (listType.IsArray)
2155 WriteLine (list + " = (" + typeMap.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", false);");
2158 WriteLineInd ("} else {");
2160 string index = GetNumTempVar ();
2161 WriteLine ("int " + index + " = 0;");
2162 WriteLine ("Reader.ReadStartElement();");
2163 WriteLine ("Reader.MoveToContent();");
2166 WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
2168 WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
2172 foreach (XmlTypeMapElementInfo elemInfo in listMap.ItemInfo)
2174 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (elemInfo.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (elemInfo.Namespace) + ") {");
2175 GenerateAddListValue (typeMap.TypeData, list, index, GenerateReadObjectElement (elemInfo), false);
2176 WriteLine (index + "++;");
2180 if (!first) WriteLine ("else UnknownNode (null);");
2181 else WriteLine ("UnknownNode (null);");
2184 WriteLine ("else UnknownNode (null);");
2186 WriteLine ("Reader.MoveToContent();");
2189 WriteLine ("ReadEndElement();");
2191 if (listType.IsArray)
2192 WriteLine (list + " = (" + typeMap.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", false);");
2201 string GenerateReadListString (XmlTypeMapping typeMap, string values)
2203 Type listType = typeMap.TypeData.Type;
2204 ListMap listMap = (ListMap)typeMap.ObjectMap;
2205 string itemType = ToCSharpFullName (listType.GetElementType());
2207 string list = GetObTempVar ();
2208 WriteLine (itemType + "[] " + list + ";");
2210 string var = GetStrTempVar ();
2211 WriteLine ("string " + var + " = " + values + ".Trim();");
2212 WriteLineInd ("if (" + var + " != string.Empty) {");
2214 string valueArray = GetObTempVar ();
2215 WriteLine ("string[] " + valueArray + " = " + var + ".Split (' ');");
2217 WriteLine (list + " = new " + GetArrayDeclaration (listType, valueArray + ".Length") + ";");
2219 XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
2221 string index = GetNumTempVar ();
2222 WriteLineInd ("for (int " + index + " = 0; " + index + " < " + valueArray + ".Length; " + index + "++)");
2223 WriteLine (list + "[" + index + "] = " + GenerateGetValueFromXmlString (valueArray + "[" + index + "]", info.TypeData, info.MappedType) + ";");
2227 WriteLine ("\t" + list + " = new " + GetArrayDeclaration (listType, "0") + ";");
2232 string GetArrayDeclaration (Type type, string length)
2234 Type t = type.GetElementType();
2235 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
2236 sb.Append ('[').Append (length).Append (']');
2239 t = t.GetElementType();
2241 sb.Insert (0, ToCSharpFullName (t));
2242 return sb.ToString ();
2245 void GenerateAddListValue (TypeData listType, string list, string index, string value, bool canCreateInstance)
2247 Type type = listType.Type;
2250 WriteLine (list + " = (" + ToCSharpFullName (type) + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
2251 WriteLine (list + "[" + index + "] = " + value + ";");
2253 else // Must be IEnumerable
2255 WriteLine ("if (((object)" + list + ") == null)");
2256 if (canCreateInstance)
2257 WriteLine ("\t" + list + " = new " + listType.CSharpFullName + "();");
2259 WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.CSharpFullName) + ");");
2261 WriteLine (list + ".Add (" + value + ");");
2265 string GenerateCreateList (Type listType)
2267 if (listType.IsArray)
2268 return "(" + ToCSharpFullName (listType) + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
2270 return "new " + ToCSharpFullName (listType) + "()";
2273 string GenerateInitializeList (TypeData listType)
2275 if (listType.Type.IsArray)
2278 return "new " + listType.CSharpFullName + "()";
2281 void GenerateFillerCallbacks ()
2283 foreach (TypeData td in _listsToFill)
2285 string metName = GetFillListName (td);
2286 WriteLine ("void " + metName + " (object list, object source)");
2288 WriteLine ("if (((object)list) == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.CSharpFullName) + ");");
2291 WriteLine (td.CSharpFullName + " dest = (" + td.CSharpFullName + ") list;");
2292 WriteLine ("foreach (object ob in (IEnumerable)source)");
2293 WriteLine ("\tdest.Add (" + GetCast (td.ListItemTypeData, "ob") + ");");
2299 void GenerateReadXmlNodeElement (XmlTypeMapping typeMap, string isNullable)
2301 WriteLine ("return " + GetReadXmlNode (typeMap.TypeData, false) + ";");
2304 void GenerateReadPrimitiveElement (XmlTypeMapping typeMap, string isNullable)
2306 WriteLine ("XmlQualifiedName t = GetXsiType();");
2307 WriteLine ("if (t == null) t = new XmlQualifiedName (" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.Namespace) + ");");
2308 WriteLine ("return " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
2311 void GenerateReadEnumElement (XmlTypeMapping typeMap, string isNullable)
2313 WriteLine ("Reader.ReadStartElement ();");
2314 WriteLine (typeMap.TypeData.CSharpFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
2315 WriteLineInd ("if (Reader.NodeType != XmlNodeType.None)");
2316 WriteLineUni ("Reader.ReadEndElement ();");
2317 WriteLine ("return res;");
2320 string GenerateGetEnumValue (XmlTypeMapping typeMap, string val)
2322 return GetGetEnumValueName (typeMap) + " (" + val + ")";
2325 void GenerateGetEnumValue (XmlTypeMapping typeMap)
2327 string metName = GetGetEnumValueName (typeMap);
2328 EnumMap map = (EnumMap) typeMap.ObjectMap;
2332 string switchMethod = metName + "_Switch";
2333 WriteLine (typeMap.TypeData.CSharpFullName + " " + metName + " (string xmlName)");
2335 WriteLine ("xmlName = xmlName.Trim();");
2336 WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeData.CSharpFullName + ")0;");
2337 WriteLine (typeMap.TypeData.CSharpFullName + " sb = (" + typeMap.TypeData.CSharpFullName + ")0;");
2338 WriteLine ("string[] enumNames = xmlName.Split (null);");
2339 WriteLine ("foreach (string name in enumNames)");
2341 WriteLine ("if (name == string.Empty) continue;");
2342 WriteLine ("sb |= " + switchMethod + " (name); ");
2344 WriteLine ("return sb;");
2347 metName = switchMethod;
2350 WriteLine (typeMap.TypeData.CSharpFullName + " " + metName + " (string xmlName)");
2352 GenerateGetSingleEnumValue (typeMap, "xmlName");
2357 void GenerateGetSingleEnumValue (XmlTypeMapping typeMap, string val)
2359 EnumMap map = (EnumMap) typeMap.ObjectMap;
2360 WriteLine ("switch (" + val + ")");
2362 foreach (EnumMap.EnumMapMember mem in map.Members)
2364 WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeData.CSharpFullName + "." + mem.EnumName + ";");
2366 WriteLineInd ("default:");
2367 WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeData.CSharpFullName + "));");
2372 void GenerateReadXmlSerializableElement (XmlTypeMapping typeMap, string isNullable)
2374 WriteLine ("Reader.MoveToContent ();");
2375 WriteLine ("if (Reader.NodeType == XmlNodeType.Element)");
2377 WriteLine ("if (Reader.LocalName == " + GetLiteral (typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
2378 WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.CSharpFullName + "());");
2380 WriteLine ("\tthrow CreateUnknownNodeException ();");
2382 WriteLine ("else UnknownNode (null);");
2384 WriteLine ("return null;");
2387 void GenerateReadInitCallbacks ()
2389 WriteLine ("protected override void InitCallbacks ()");
2392 if (_format == SerializationFormat.Encoded)
2394 foreach (XmlMapping xmap in _mapsToGenerate)
2396 XmlTypeMapping map = xmap as XmlTypeMapping;
2397 if (map == null) continue;
2398 if (map.TypeData.SchemaType == SchemaTypes.Class || map.TypeData.SchemaType == SchemaTypes.Enum)
2399 WriteMetCall ("AddReadCallback", GetLiteral (map.XmlType), GetLiteral(map.Namespace), GetTypeOf(map.TypeData.Type), "new XmlSerializationReadCallback (" + GetReadObjectName (map) + ")");
2406 WriteLine ("protected override void InitIDs ()");
2412 void GenerateFixupCallbacks ()
2414 foreach (XmlMapping map in _fixupCallbacks)
2416 bool isList = map is XmlMembersMapping;
2417 string tname = !isList ? ((XmlTypeMapping)map).TypeData.CSharpFullName : "object[]";
2418 WriteLine ("void " + GetFixupCallbackName (map) + " (object obfixup)");
2420 WriteLine ("Fixup fixup = (Fixup)obfixup;");
2421 WriteLine (tname + " source = (" + tname + ") fixup.Source;");
2422 WriteLine ("string[] ids = fixup.Ids;");
2425 ClassMap cmap = (ClassMap)map.ObjectMap;
2426 ICollection members = cmap.ElementMembers;
2427 if (members != null) {
2428 foreach (XmlTypeMapMember member in members)
2430 WriteLineInd ("if (ids[" + member.Index + "] != null)");
2431 string val = "GetTarget(ids[" + member.Index + "])";
2432 if (!isList) val = GetCast (member.TypeData, val);
2433 GenerateSetMemberValue (member, "source", val, isList);
2442 string GetReadXmlNode (TypeData type, bool wrapped)
2444 if (type.Type == typeof (XmlDocument))
2445 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlDocument)), "ReadXmlDocument (" + GetLiteral(wrapped) + ")");
2447 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlNode)), "ReadXmlNode (" + GetLiteral(wrapped) + ")");
2452 #region Helper methods
2454 //*******************************************************
2458 ArrayList _listsToFill = new ArrayList ();
2459 Hashtable _hookVariables;
2460 Stack _hookContexts;
2461 Stack _hookOpenHooks;
2464 public HookType HookType;
2466 public string Member;
2467 public HookDir Direction;
2472 _hookContexts = new Stack ();
2473 _hookOpenHooks = new Stack ();
2474 _hookVariables = new Hashtable ();
2477 void PushHookContext ()
2479 _hookContexts.Push (_hookVariables);
2480 _hookVariables = (Hashtable) _hookVariables.Clone ();
2483 void PopHookContext ()
2485 _hookVariables = (Hashtable) _hookContexts.Pop ();
2488 void SetHookVar (string var, string value)
2490 _hookVariables [var] = value;
2493 bool GenerateReadHook (HookType hookType, Type type)
2495 return GenerateHook (hookType, HookDir.Read, type, null);
2498 bool GenerateWriteHook (HookType hookType, Type type)
2500 return GenerateHook (hookType, HookDir.Write, type, null);
2503 bool GenerateWriteMemberHook (Type type, XmlTypeMapMember member)
2505 SetHookVar ("$MEMBER", member.Name);
2506 return GenerateHook (HookType.member, HookDir.Write, type, member.Name);
2509 bool GenerateReadMemberHook (Type type, XmlTypeMapMember member)
2511 SetHookVar ("$MEMBER", member.Name);
2512 return GenerateHook (HookType.member, HookDir.Read, type, member.Name);
2515 bool GenerateReadArrayMemberHook (Type type, XmlTypeMapMember member, string index)
2517 SetHookVar ("$INDEX", index);
2518 return GenerateReadMemberHook (type, member);
2521 bool MemberHasReadReplaceHook (Type type, XmlTypeMapMember member)
2523 if (_config == null) return false;
2524 return _config.GetHooks (HookType.member, HookDir.Read, HookAction.Replace, type, member.Name).Count > 0;
2527 bool GenerateHook (HookType hookType, HookDir dir, Type type, string member)
2529 GenerateHooks (hookType, dir, type, null, HookAction.InsertBefore);
2530 if (GenerateHooks (hookType, dir, type, null, HookAction.Replace))
2532 GenerateHooks (hookType, dir, type, null, HookAction.InsertAfter);
2537 HookInfo hi = new HookInfo ();
2538 hi.HookType = hookType;
2542 _hookOpenHooks.Push (hi);
2547 void GenerateEndHook ()
2549 HookInfo hi = (HookInfo) _hookOpenHooks.Pop();
2550 GenerateHooks (hi.HookType, hi.Direction, hi.Type, hi.Member, HookAction.InsertAfter);
2553 bool GenerateHooks (HookType hookType, HookDir dir, Type type, string member, HookAction action)
2555 if (_config == null) return false;
2556 ArrayList hooks = _config.GetHooks (hookType, dir, action, type, null);
2557 if (hooks.Count == 0) return false;
2558 foreach (Hook hook in hooks)
2560 string code = hook.GetCode (action);
2561 foreach (DictionaryEntry de in _hookVariables)
2562 code = code.Replace ((string)de.Key, (string)de.Value);
2563 WriteMultilineCode (code);
2568 string GetRootTypeName ()
2570 if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeData.CSharpFullName;
2571 else return "object[]";
2574 string GetNumTempVar ()
2576 return "n" + (_tempVarId++);
2579 string GetObTempVar ()
2581 return "o" + (_tempVarId++);
2584 string GetStrTempVar ()
2586 return "s" + (_tempVarId++);
2589 string GetBoolTempVar ()
2591 return "b" + (_tempVarId++);
2594 string GetUniqueName (string uniqueGroup, object ob, string name)
2596 name = name.Replace ("[]","_array");
2597 Hashtable names = (Hashtable) _uniqueNames [uniqueGroup];
2598 if (names == null) {
2599 names = new Hashtable ();
2600 _uniqueNames [uniqueGroup] = names;
2603 string res = (string) names [ob];
2604 if (res != null) return res;
2606 foreach (string n in names.Values)
2607 if (n == name) return GetUniqueName (uniqueGroup, ob, name + (_methodId++));
2613 void RegisterReferencingMap (XmlTypeMapping typeMap)
2615 if (typeMap != null && !_mapsToGenerate.Contains (typeMap))
2616 _mapsToGenerate.Add (typeMap);
2619 string GetWriteObjectName (XmlTypeMapping typeMap)
2621 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2622 return GetUniqueName ("rw", typeMap, "WriteObject_" + typeMap.XmlType);
2625 string GetReadObjectName (XmlTypeMapping typeMap)
2627 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2628 return GetUniqueName ("rr", typeMap, "ReadObject_" + typeMap.XmlType);
2631 string GetGetEnumValueName (XmlTypeMapping typeMap)
2633 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2634 return GetUniqueName ("ge", typeMap, "GetEnumValue_" + typeMap.XmlType);
2637 string GetWriteObjectCallbackName (XmlTypeMapping typeMap)
2639 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2640 return GetUniqueName ("wc", typeMap, "WriteCallback_" + typeMap.XmlType);
2643 string GetFixupCallbackName (XmlMapping typeMap)
2645 if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2647 if (typeMap is XmlTypeMapping)
2648 return GetUniqueName ("fc", typeMap, "FixupCallback_" + ((XmlTypeMapping)typeMap).XmlType);
2650 return GetUniqueName ("fc", typeMap, "FixupCallback__Message");
2653 string GetUniqueClassName (string s)
2655 return classNames.AddUnique (s, null);
2658 string GetReadObjectCall (XmlTypeMapping typeMap, string isNullable, string checkType)
2660 if (_format == SerializationFormat.Literal)
2661 return GetReadObjectName (typeMap) + " (" + isNullable + ", " + checkType + ")";
2663 return GetCast (typeMap.TypeData, GetReadObjectName (typeMap) + " ()");
2666 string GetFillListName (TypeData td)
2668 if (!_listsToFill.Contains (td)) _listsToFill.Add (td);
2669 return GetUniqueName ("fl", td, "Fill_" + CodeIdentifier.MakeValid (td.CSharpName));
2672 string GetCast (TypeData td, TypeData tdval, string val)
2674 if (td.CSharpFullName == tdval.CSharpFullName) return val;
2675 else return GetCast (td, val);
2678 string GetCast (TypeData td, string val)
2680 return "((" + td.CSharpFullName + ") " + val + ")";
2683 string GetCast (Type td, string val)
2685 return "((" + ToCSharpFullName (td) + ") " + val + ")";
2688 string GetTypeOf (TypeData td)
2690 return "typeof(" + td.CSharpFullName + ")";
2693 string GetTypeOf (Type td)
2695 return "typeof(" + ToCSharpFullName (td) + ")";
2698 string GetLiteral (object ob)
2700 if (ob == null) return "null";
2701 if (ob is string) return "\"" + ob.ToString().Replace("\"","\"\"") + "\"";
2702 if (ob is bool) return ((bool)ob) ? "true" : "false";
2703 if (ob is XmlQualifiedName) {
2704 XmlQualifiedName qn = (XmlQualifiedName)ob;
2705 return "new XmlQualifiedName (" + GetLiteral(qn.Name) + "," + GetLiteral(qn.Namespace) + ")";
2708 string typeName = ToCSharpFullName (ob.GetType ());
2709 StringBuilder sb = new StringBuilder ();
2710 string namedValue = Enum.Format (ob.GetType (), ob, "g");
2711 string[] names = namedValue.Split (',');
2712 foreach (string name in names) {
2713 // individual named constants can be seperated by a comma
2714 // combined with some additional whitespace characters
2715 string cleanName = name.Trim ();
2716 if (cleanName.Length == 0)
2722 sb.Append (typeName);
2724 sb.Append (cleanName);
2726 return sb.ToString ();
2729 return (ob is IFormattable) ? ((IFormattable) ob).ToString (null, CultureInfo.InvariantCulture) : ob.ToString ();
2732 void WriteLineInd (string code)
2738 void WriteLineUni (string code)
2740 if (_indent > 0) _indent--;
2744 void Write (string code)
2746 if (code.Length > 0)
2747 _writer.Write (new String ('\t', _indent));
2748 _writer.Write (code);
2751 void WriteUni (string code)
2753 if (_indent > 0) _indent--;
2754 _writer.Write (code);
2755 _writer.WriteLine (string.Empty);
2758 void WriteLine (string code)
2760 if (code.Length > 0)
2761 _writer.Write (new String ('\t',_indent));
2762 _writer.WriteLine (code);
2765 void WriteMultilineCode (string code)
2767 string tabs = new string ('\t',_indent);
2768 code = code.Replace ("\r","");
2769 code = code.Replace ("\t","");
2770 while (code.StartsWith ("\n")) code = code.Substring (1);
2771 while (code.EndsWith ("\n")) code = code.Substring (0, code.Length - 1);
2772 code = code.Replace ("\n", "\n" + tabs);
2776 string Params (params string[] pars)
2779 foreach (string p in pars)
2781 if (res != "") res += ", ";
2787 void WriteMetCall (string method, params string[] pars)
2789 WriteLine (method + " (" + Params (pars) + ");");
2801 internal class GenerationResult
2803 public XmlMapping Mapping;
2804 public string ReaderClassName;
2805 public string ReadMethodName;
2806 public string WriterClassName;
2807 public string WriteMethodName;
2808 public string Namespace;
2809 public string SerializerClassName;
2810 public string BaseSerializerClassName;
2811 public string ImplementationClassName;