PageRenderTime 58ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 1ms

/mcs/class/System.XML/System.Xml.Serialization/SerializationCodeGenerator.cs

https://bitbucket.org/danipen/mono
C# | 2917 lines | 2781 code | 88 blank | 48 comment | 193 complexity | 3ec4f83bd417b125b597f9cdd8bb7fef MD5 | raw file
Possible License(s): Unlicense, Apache-2.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0

Large files files are truncated, but you can click here to view the full file

  1. //
  2. // System.Xml.Serialization.SerializationCodeGenerator.cs:
  3. //
  4. // Authors:
  5. // Lluis Sanchez Gual (lluis@ximian.com)
  6. // Atsushi Enomoto (atsushi@ximian.com)
  7. //
  8. // (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
  9. // Copyright (C) 2006 Novell, Inc.
  10. //
  11. //
  12. // Permission is hereby granted, free of charge, to any person obtaining
  13. // a copy of this software and associated documentation files (the
  14. // "Software"), to deal in the Software without restriction, including
  15. // without limitation the rights to use, copy, modify, merge, publish,
  16. // distribute, sublicense, and/or sell copies of the Software, and to
  17. // permit persons to whom the Software is furnished to do so, subject to
  18. // the following conditions:
  19. //
  20. // The above copyright notice and this permission notice shall be
  21. // included in all copies or substantial portions of the Software.
  22. //
  23. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27. // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28. // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30. //
  31. using System.IO;
  32. using System.Reflection;
  33. using System.Xml.Serialization;
  34. using System.Collections;
  35. using System.Globalization;
  36. using System.Text;
  37. using HookDir = System.Xml.Serialization.XmlMappingAccess;
  38. namespace System.Xml.Serialization
  39. {
  40. internal class SerializationCodeGenerator
  41. {
  42. XmlMapping _typeMap;
  43. SerializationFormat _format;
  44. TextWriter _writer;
  45. int _tempVarId = 0;
  46. int _indent = 0;
  47. Hashtable _uniqueNames = new Hashtable();
  48. int _methodId = 0;
  49. SerializerInfo _config;
  50. ArrayList _mapsToGenerate = new ArrayList ();
  51. ArrayList _fixupCallbacks;
  52. ArrayList _referencedTypes = new ArrayList ();
  53. GenerationResult[] _results;
  54. GenerationResult _result;
  55. XmlMapping[] _xmlMaps;
  56. CodeIdentifiers classNames = new CodeIdentifiers ();
  57. public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
  58. {
  59. }
  60. public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
  61. {
  62. _xmlMaps = xmlMaps;
  63. _config = config;
  64. }
  65. public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
  66. {
  67. _xmlMaps = new XmlMapping [] {xmlMap};
  68. _config = config;
  69. }
  70. public static void Generate (string configFileName, string outputPath)
  71. {
  72. SerializationCodeGeneratorConfiguration cnf = null;
  73. StreamReader sr = new StreamReader (configFileName);
  74. try
  75. {
  76. XmlReflectionImporter ri = new XmlReflectionImporter ();
  77. ri.AllowPrivateTypes = true;
  78. XmlSerializer ser = new XmlSerializer (ri.ImportTypeMapping (typeof (SerializationCodeGeneratorConfiguration)));
  79. cnf = (SerializationCodeGeneratorConfiguration) ser.Deserialize (sr);
  80. }
  81. finally
  82. {
  83. sr.Close ();
  84. }
  85. if (outputPath == null) outputPath = "";
  86. CodeIdentifiers ids = new CodeIdentifiers ();
  87. if (cnf.Serializers != null)
  88. {
  89. foreach (SerializerInfo info in cnf.Serializers)
  90. {
  91. Type type;
  92. if (info.Assembly != null)
  93. {
  94. Assembly asm;
  95. try {
  96. asm = Assembly.Load (info.Assembly);
  97. } catch {
  98. asm = Assembly.LoadFrom (info.Assembly);
  99. }
  100. type = asm.GetType (info.ClassName, true);
  101. }
  102. else
  103. type = Type.GetType (info.ClassName);
  104. if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
  105. string file = info.OutFileName;
  106. if (file == null || file.Length == 0) {
  107. int i = info.ClassName.LastIndexOf (".");
  108. if (i != -1) file = info.ClassName.Substring (i+1);
  109. else file = info.ClassName;
  110. file = ids.AddUnique (file, type) + "Serializer.cs";
  111. }
  112. StreamWriter writer = new StreamWriter (Path.Combine (outputPath, file));
  113. try
  114. {
  115. XmlTypeMapping map;
  116. if (info.SerializationFormat == SerializationFormat.Literal) {
  117. XmlReflectionImporter ri = new XmlReflectionImporter ();
  118. map = ri.ImportTypeMapping (type);
  119. }
  120. else {
  121. SoapReflectionImporter ri = new SoapReflectionImporter ();
  122. map = ri.ImportTypeMapping (type);
  123. }
  124. SerializationCodeGenerator gen = new SerializationCodeGenerator (map, info);
  125. gen.GenerateSerializers (writer);
  126. }
  127. finally
  128. {
  129. writer.Close ();
  130. }
  131. }
  132. }
  133. }
  134. public void GenerateSerializers (TextWriter writer)
  135. {
  136. _writer = writer;
  137. _results = new GenerationResult [_xmlMaps.Length];
  138. WriteLine ("// It is automatically generated");
  139. WriteLine ("using System;");
  140. WriteLine ("using System.Xml;");
  141. WriteLine ("using System.Xml.Schema;");
  142. WriteLine ("using System.Xml.Serialization;");
  143. WriteLine ("using System.Text;");
  144. WriteLine ("using System.Collections;");
  145. WriteLine ("using System.Globalization;");
  146. if (_config != null && _config.NamespaceImports != null && _config.NamespaceImports.Length > 0) {
  147. foreach (string ns in _config.NamespaceImports)
  148. WriteLine ("using " + ns + ";");
  149. }
  150. WriteLine ("");
  151. string readerClassName = null;
  152. string writerClassName = null;
  153. string baseClassName = null;
  154. string implClassName = null;
  155. string namspace = null;
  156. if (_config != null)
  157. {
  158. readerClassName = _config.ReaderClassName;
  159. writerClassName = _config.WriterClassName;
  160. baseClassName = _config.BaseSerializerClassName;
  161. implClassName = _config.ImplementationClassName;
  162. namspace = _config.Namespace;
  163. }
  164. if (readerClassName == null || readerClassName.Length == 0)
  165. readerClassName = "GeneratedReader";
  166. if (writerClassName == null || writerClassName.Length == 0)
  167. writerClassName = "GeneratedWriter";
  168. if (baseClassName == null || baseClassName.Length == 0)
  169. baseClassName = "BaseXmlSerializer";
  170. if (implClassName == null || implClassName.Length == 0)
  171. implClassName = "XmlSerializerContract";
  172. readerClassName = GetUniqueClassName (readerClassName);
  173. writerClassName = GetUniqueClassName (writerClassName);
  174. baseClassName = GetUniqueClassName (baseClassName);
  175. implClassName = GetUniqueClassName (implClassName);
  176. Hashtable mapsByNamespace = new Hashtable ();
  177. Hashtable generatedMaps = new Hashtable ();
  178. for (int n=0; n<_xmlMaps.Length; n++)
  179. {
  180. _typeMap = _xmlMaps [n];
  181. if (_typeMap == null) continue;
  182. _result = generatedMaps [_typeMap] as GenerationResult;
  183. if (_result != null) {
  184. _results[n] = _result;
  185. continue;
  186. }
  187. _result = new GenerationResult ();
  188. _results[n] = _result;
  189. generatedMaps [_typeMap] = _result;
  190. string typeName;
  191. if (_typeMap is XmlTypeMapping) typeName = CodeIdentifier.MakeValid (((XmlTypeMapping)_typeMap).TypeData.CSharpName);
  192. else typeName = ((XmlMembersMapping)_typeMap).ElementName;
  193. _result.ReaderClassName = readerClassName;
  194. _result.WriterClassName = writerClassName;
  195. _result.BaseSerializerClassName = baseClassName;
  196. _result.ImplementationClassName = implClassName;
  197. if (namspace == null || namspace.Length == 0)
  198. _result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
  199. else
  200. _result.Namespace = namspace;
  201. _result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
  202. _result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
  203. _result.Mapping = _typeMap;
  204. ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
  205. if (maps == null) {
  206. maps = new ArrayList ();
  207. mapsByNamespace [_result.Namespace] = maps;
  208. }
  209. maps.Add (_result);
  210. }
  211. foreach (DictionaryEntry entry in mapsByNamespace)
  212. {
  213. ArrayList maps = (ArrayList) entry.Value;
  214. WriteLine ("namespace " + entry.Key);
  215. WriteLineInd ("{");
  216. if (_config == null || !_config.NoReader)
  217. GenerateReader (readerClassName, maps);
  218. WriteLine ("");
  219. if (_config == null || !_config.NoWriter)
  220. GenerateWriter (writerClassName, maps);
  221. WriteLine ("");
  222. #if NET_2_0
  223. GenerateContract (maps);
  224. #endif
  225. WriteLineUni ("}");
  226. WriteLine ("");
  227. }
  228. }
  229. public GenerationResult[] GenerationResults
  230. {
  231. get { return _results; }
  232. }
  233. public ArrayList ReferencedTypes
  234. {
  235. get { return _referencedTypes; }
  236. }
  237. void UpdateGeneratedTypes (ArrayList list)
  238. {
  239. for (int n=0; n<list.Count; n++)
  240. {
  241. XmlTypeMapping map = list[n] as XmlTypeMapping;
  242. if (map != null && !_referencedTypes.Contains (map.TypeData.Type))
  243. _referencedTypes.Add (map.TypeData.Type);
  244. }
  245. }
  246. static string ToCSharpFullName (Type type)
  247. {
  248. return TypeData.ToCSharpName (type, true);
  249. }
  250. #region Writer Generation
  251. //*******************************************************
  252. // Contract generation
  253. //
  254. #if NET_2_0
  255. public void GenerateContract (ArrayList generatedMaps)
  256. {
  257. // Write the base serializer
  258. if (generatedMaps.Count == 0) return;
  259. GenerationResult main = (GenerationResult) generatedMaps[0];
  260. string baseSerializerName = main.BaseSerializerClassName;
  261. string access_mod = (_config == null || !_config.GenerateAsInternal) ? "public" : "internal";
  262. WriteLine ("");
  263. WriteLine (access_mod + " class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
  264. WriteLineInd ("{");
  265. WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
  266. WriteLine ("return new " + main.ReaderClassName + " ();");
  267. WriteLineUni ("}");
  268. WriteLine ("");
  269. WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {");
  270. WriteLine ("return new " + main.WriterClassName + " ();");
  271. WriteLineUni ("}");
  272. WriteLine ("");
  273. WriteLineInd ("public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {");
  274. WriteLine ("return true;");
  275. WriteLineUni ("}");
  276. WriteLineUni ("}");
  277. WriteLine ("");
  278. // Write a serializer for each imported map
  279. foreach (GenerationResult res in generatedMaps)
  280. {
  281. res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
  282. WriteLine (access_mod + " sealed class " + res.SerializerClassName + " : " + baseSerializerName);
  283. WriteLineInd ("{");
  284. WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
  285. WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
  286. WriteLineUni ("}");
  287. WriteLine ("");
  288. WriteLineInd ("protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {");
  289. WriteLine ("return ((" + res.ReaderClassName + ")reader)." + res.ReadMethodName + "();");
  290. WriteLineUni ("}");
  291. WriteLineUni ("}");
  292. WriteLine ("");
  293. }
  294. WriteLine ("#if !TARGET_JVM"); // does it make sense? ;-)
  295. WriteLine (access_mod + " class " + main.ImplementationClassName + " : System.Xml.Serialization.XmlSerializerImplementation");
  296. WriteLineInd ("{");
  297. WriteLine ("System.Collections.Hashtable readMethods = null;");
  298. WriteLine ("System.Collections.Hashtable writeMethods = null;");
  299. WriteLine ("System.Collections.Hashtable typedSerializers = null;");
  300. WriteLine ("");
  301. WriteLineInd ("public override System.Xml.Serialization.XmlSerializationReader Reader {");
  302. WriteLineInd ("get {");
  303. WriteLine ("return new " + main.ReaderClassName + "();");
  304. WriteLineUni ("}");
  305. WriteLineUni ("}");
  306. WriteLine ("");
  307. WriteLineInd ("public override System.Xml.Serialization.XmlSerializationWriter Writer {");
  308. WriteLineInd ("get {");
  309. WriteLine ("return new " + main.WriterClassName + "();");
  310. WriteLineUni ("}");
  311. WriteLineUni ("}");
  312. WriteLine ("");
  313. WriteLineInd ("public override System.Collections.Hashtable ReadMethods {");
  314. WriteLineInd ("get {");
  315. WriteLineInd ("lock (this) {");
  316. WriteLineInd ("if (readMethods == null) {");
  317. WriteLine ("readMethods = new System.Collections.Hashtable ();");
  318. foreach (GenerationResult res in generatedMaps)
  319. WriteLine ("readMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.ReadMethodName + "\");");
  320. WriteLineUni ("}");
  321. WriteLine ("return readMethods;");
  322. WriteLineUni ("}");
  323. WriteLineUni ("}");
  324. WriteLineUni ("}");
  325. WriteLine ("");
  326. WriteLineInd ("public override System.Collections.Hashtable WriteMethods {");
  327. WriteLineInd ("get {");
  328. WriteLineInd ("lock (this) {");
  329. WriteLineInd ("if (writeMethods == null) {");
  330. WriteLine ("writeMethods = new System.Collections.Hashtable ();");
  331. foreach (GenerationResult res in generatedMaps)
  332. WriteLine ("writeMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.WriteMethodName + "\");");
  333. WriteLineUni ("}");
  334. WriteLine ("return writeMethods;");
  335. WriteLineUni ("}");
  336. WriteLineUni ("}");
  337. WriteLineUni ("}");
  338. WriteLine ("");
  339. WriteLineInd ("public override System.Collections.Hashtable TypedSerializers {");
  340. WriteLineInd ("get {");
  341. WriteLineInd ("lock (this) {");
  342. WriteLineInd ("if (typedSerializers == null) {");
  343. WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
  344. foreach (GenerationResult res in generatedMaps)
  345. WriteLine ("typedSerializers.Add (@\"" + res.Mapping.GetKey () + "\", new " + res.SerializerClassName + "());");
  346. WriteLineUni ("}");
  347. WriteLine ("return typedSerializers;");
  348. WriteLineUni ("}");
  349. WriteLineUni ("}");
  350. WriteLineUni ("}");
  351. WriteLine ("");
  352. WriteLine ("public override XmlSerializer GetSerializer (Type type)");
  353. WriteLineInd ("{");
  354. WriteLine ("switch (type.FullName) {");
  355. foreach (GenerationResult res in generatedMaps) {
  356. if (res.Mapping is XmlTypeMapping) {
  357. WriteLineInd ("case \"" + ((XmlTypeMapping) res.Mapping).TypeData.CSharpFullName + "\":");
  358. WriteLine ("return (XmlSerializer) TypedSerializers [\"" + res.Mapping.GetKey () + "\"];");
  359. WriteLineUni ("");
  360. }
  361. }
  362. WriteLine ("}");
  363. WriteLine ("return base.GetSerializer (type);");
  364. WriteLineUni ("}");
  365. WriteLine ("");
  366. WriteLineInd ("public override bool CanSerialize (System.Type type) {");
  367. foreach (GenerationResult res in generatedMaps) {
  368. if (res.Mapping is XmlTypeMapping)
  369. WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.CSharpFullName + ")) return true;");
  370. }
  371. WriteLine ("return false;");
  372. WriteLineUni ("}");
  373. WriteLineUni ("}");
  374. WriteLine ("");
  375. WriteLine ("#endif");
  376. }
  377. #endif
  378. //*******************************************************
  379. // Writer generation
  380. //
  381. public void GenerateWriter (string writerClassName, ArrayList maps)
  382. {
  383. _mapsToGenerate = new ArrayList ();
  384. InitHooks ();
  385. if (_config == null || !_config.GenerateAsInternal)
  386. WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
  387. else
  388. WriteLine ("internal class " + writerClassName + " : XmlSerializationWriter");
  389. WriteLineInd ("{");
  390. WriteLine ("const string xmlNamespace = \"http://www.w3.org/2000/xmlns/\";");
  391. // ToBinHexString() is not public, so use reflection here.
  392. WriteLine ("static readonly System.Reflection.MethodInfo toBinHexStringMethod = typeof (XmlConvert).GetMethod (\"ToBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (byte [])}, null);");
  393. WriteLine ("static string ToBinHexString (byte [] input)");
  394. WriteLineInd ("{");
  395. WriteLine ("return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});");
  396. WriteLineUni ("}");
  397. for (int n=0; n<maps.Count; n++)
  398. {
  399. GenerationResult res = (GenerationResult) maps [n];
  400. _typeMap = res.Mapping;
  401. _format = _typeMap.Format;
  402. _result = res;
  403. GenerateWriteRoot ();
  404. }
  405. for (int n=0; n<_mapsToGenerate.Count; n++)
  406. {
  407. XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
  408. GenerateWriteObject (map);
  409. if (map.TypeData.SchemaType == SchemaTypes.Enum)
  410. GenerateGetXmlEnumValue (map);
  411. }
  412. GenerateWriteInitCallbacks ();
  413. UpdateGeneratedTypes (_mapsToGenerate);
  414. WriteLineUni ("}");
  415. }
  416. void GenerateWriteRoot ()
  417. {
  418. WriteLine ("public void " +_result.WriteMethodName + " (object o)");
  419. WriteLineInd ("{");
  420. WriteLine ("WriteStartDocument ();");
  421. if (_typeMap is XmlTypeMapping)
  422. {
  423. WriteLine (GetRootTypeName () + " ob = (" + GetRootTypeName () + ") o;");
  424. XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
  425. if (mp.TypeData.SchemaType == SchemaTypes.Class || mp.TypeData.SchemaType == SchemaTypes.Array)
  426. WriteLine ("TopLevelElement ();");
  427. if (_format == SerializationFormat.Literal) {
  428. WriteLine (GetWriteObjectName (mp) + " (ob, " + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", true, false, true);");
  429. }
  430. else {
  431. RegisterReferencingMap (mp);
  432. WriteLine ("WritePotentiallyReferencingElement (" + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", ob, " + GetTypeOf(mp.TypeData) + ", true, false);");
  433. }
  434. }
  435. else if (_typeMap is XmlMembersMapping) {
  436. WriteLine ("object[] pars = (object[]) o;");
  437. GenerateWriteMessage ((XmlMembersMapping) _typeMap);
  438. }
  439. else
  440. throw new InvalidOperationException ("Unknown type map");
  441. if (_format == SerializationFormat.Encoded)
  442. WriteLine ("WriteReferencedElements ();");
  443. WriteLineUni ("}");
  444. WriteLine ("");
  445. }
  446. void GenerateWriteMessage (XmlMembersMapping membersMap)
  447. {
  448. if (membersMap.HasWrapperElement) {
  449. WriteLine ("TopLevelElement ();");
  450. WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));");
  451. /* WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)");
  452. WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);");
  453. Unindent ();
  454. WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)");
  455. WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);");
  456. Unindent ();
  457. */
  458. }
  459. GenerateWriteObjectElement (membersMap, "pars", true);
  460. if (membersMap.HasWrapperElement)
  461. WriteLine ("WriteEndElement();");
  462. }
  463. void GenerateGetXmlEnumValue (XmlTypeMapping map)
  464. {
  465. EnumMap emap = (EnumMap) map.ObjectMap;
  466. string xmlNamesArray = null;
  467. string valuesArray = null;
  468. if (emap.IsFlags) {
  469. // create static string[] holding XML names of enum constants
  470. xmlNamesArray = GetUniqueName ("gxe", map, "_xmlNames" + map.XmlType);
  471. Write ("static readonly string[] " + xmlNamesArray + " = { ");
  472. for (int i = 0; i < emap.XmlNames.Length; i++) {
  473. if (i > 0)
  474. _writer.Write (',');
  475. _writer.Write ('"');
  476. _writer.Write (emap.XmlNames[i]);
  477. _writer.Write ('\"');
  478. }
  479. _writer.WriteLine (" };");
  480. // create const long[] holding values of enum constants
  481. valuesArray = GetUniqueName ("gve", map, "_values" + map.XmlType);
  482. Write ("static readonly long[] " + valuesArray + " = { ");
  483. for (int i = 0; i < emap.Values.Length; i++) {
  484. if (i > 0)
  485. _writer.Write (',');
  486. _writer.Write (emap.Values[i].ToString (CultureInfo.InvariantCulture));
  487. _writer.Write ("L");
  488. }
  489. _writer.WriteLine (" };");
  490. WriteLine (string.Empty);
  491. }
  492. WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeData.CSharpFullName + " val)");
  493. WriteLineInd ("{");
  494. WriteLineInd ("switch (val) {");
  495. for (int i = 0; i < emap.EnumNames.Length; i++)
  496. WriteLine ("case " + map.TypeData.CSharpFullName + ".@" + emap.EnumNames[i] + ": return " + GetLiteral (emap.XmlNames[i]) + ";");
  497. if (emap.IsFlags) {
  498. WriteLineInd ("default:");
  499. // FromEnum actually covers this case too, but we save some cycles here
  500. WriteLine ("if (val.ToString () == \"0\") return string.Empty;");
  501. Write ("return FromEnum ((long) val, " + xmlNamesArray + ", " + valuesArray);
  502. #if NET_2_0
  503. _writer.Write (", typeof (");
  504. _writer.Write (map.TypeData.CSharpFullName);
  505. _writer.Write (").FullName");
  506. #endif
  507. _writer.Write (')'); // close FromEnum method call
  508. WriteUni (";"); // end statement
  509. } else {
  510. #if NET_2_0
  511. WriteLine ("default: throw CreateInvalidEnumValueException ((long) val, typeof (" + map.TypeData.CSharpFullName + ").FullName);");
  512. #else
  513. WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
  514. #endif
  515. }
  516. WriteLineUni ("}");
  517. WriteLineUni ("}");
  518. WriteLine ("");
  519. }
  520. void GenerateWriteObject (XmlTypeMapping typeMap)
  521. {
  522. WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeData.CSharpFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
  523. WriteLineInd ("{");
  524. PushHookContext ();
  525. SetHookVar ("$TYPE", typeMap.TypeData.CSharpName);
  526. SetHookVar ("$FULLTYPE", typeMap.TypeData.CSharpFullName);
  527. SetHookVar ("$OBJECT", "ob");
  528. SetHookVar ("$NULLABLE", "isNullable");
  529. if (GenerateWriteHook (HookType.type, typeMap.TypeData.Type))
  530. {
  531. WriteLineUni ("}");
  532. WriteLine ("");
  533. PopHookContext ();
  534. return;
  535. }
  536. if (!typeMap.TypeData.IsValueType)
  537. {
  538. WriteLine ("if (((object)ob) == null)");
  539. WriteLineInd ("{");
  540. WriteLineInd ("if (isNullable)");
  541. if (_format == SerializationFormat.Literal)
  542. WriteLine ("WriteNullTagLiteral(element, namesp);");
  543. else
  544. WriteLine ("WriteNullTagEncoded (element, namesp);");
  545. WriteLineUni ("return;");
  546. WriteLineUni ("}");
  547. WriteLine ("");
  548. }
  549. if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
  550. {
  551. if (_format == SerializationFormat.Literal)
  552. WriteLine ("WriteElementLiteral (ob, \"\", \"\", true, false);");
  553. else
  554. WriteLine ("WriteElementEncoded (ob, \"\", \"\", true, false);");
  555. GenerateEndHook ();
  556. WriteLineUni ("}");
  557. WriteLine ("");
  558. PopHookContext ();
  559. return;
  560. }
  561. if (typeMap.TypeData.SchemaType == SchemaTypes.XmlSerializable)
  562. {
  563. WriteLine ("WriteSerializable (ob, element, namesp, isNullable);");
  564. GenerateEndHook ();
  565. WriteLineUni ("}");
  566. WriteLine ("");
  567. PopHookContext ();
  568. return;
  569. }
  570. ArrayList types = typeMap.DerivedTypes;
  571. WriteLine ("System.Type type = ob.GetType ();");
  572. WriteLine ("if (type == typeof(" + typeMap.TypeData.CSharpFullName + "))");
  573. WriteLine ("{ }");
  574. for (int n=0; n<types.Count; n++)
  575. {
  576. XmlTypeMapping map = (XmlTypeMapping)types[n];
  577. WriteLineInd ("else if (type == typeof(" + map.TypeData.CSharpFullName + ")) { ");
  578. WriteLine (GetWriteObjectName (map) + "((" + map.TypeData.CSharpFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
  579. WriteLine ("return;");
  580. WriteLineUni ("}");
  581. }
  582. if (typeMap.TypeData.Type == typeof (object)) {
  583. WriteLineInd ("else {");
  584. WriteLineInd ("if (ob.GetType().IsArray && typeof(XmlNode).IsAssignableFrom(ob.GetType().GetElementType())) {");
  585. WriteLine ("Writer.WriteStartElement (" + GetLiteral (typeMap.ElementName) + ", " + GetLiteral (typeMap.Namespace) + ");");
  586. WriteLineInd ("foreach (XmlNode node in (System.Collections.IEnumerable) ob)");
  587. WriteLineUni ("node.WriteTo (Writer);");
  588. WriteLineUni ("Writer.WriteEndElement ();");
  589. WriteLine ("}");
  590. WriteLineInd ("else");
  591. WriteLineUni ("WriteTypedPrimitive (element, namesp, ob, true);");
  592. WriteLine ("return;");
  593. WriteLineUni ("}");
  594. }
  595. else
  596. {
  597. WriteLineInd ("else {");
  598. WriteLine ("throw CreateUnknownTypeException (ob);");
  599. WriteLineUni ("}");
  600. WriteLine ("");
  601. WriteLineInd ("if (writeWrappingElem) {");
  602. if (_format == SerializationFormat.Encoded) WriteLine ("needType = true;");
  603. WriteLine ("WriteStartElement (element, namesp, ob);");
  604. WriteLineUni ("}");
  605. WriteLine ("");
  606. WriteLine ("if (needType) WriteXsiType(" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.XmlTypeNamespace) + ");");
  607. WriteLine ("");
  608. switch (typeMap.TypeData.SchemaType)
  609. {
  610. case SchemaTypes.Class: GenerateWriteObjectElement (typeMap, "ob", false); break;
  611. case SchemaTypes.Array: GenerateWriteListElement (typeMap, "ob"); break;
  612. case SchemaTypes.Primitive: GenerateWritePrimitiveElement (typeMap, "ob"); break;
  613. case SchemaTypes.Enum: GenerateWriteEnumElement (typeMap, "ob"); break;
  614. }
  615. WriteLine ("if (writeWrappingElem) WriteEndElement (ob);");
  616. }
  617. GenerateEndHook ();
  618. WriteLineUni ("}");
  619. WriteLine ("");
  620. PopHookContext ();
  621. }
  622. void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
  623. {
  624. XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
  625. Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
  626. ClassMap map = (ClassMap)xmlMap.ObjectMap;
  627. if (!GenerateWriteHook (HookType.attributes, xmlMapType))
  628. {
  629. if (map.NamespaceDeclarations != null) {
  630. WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
  631. WriteLine ("");
  632. }
  633. XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
  634. if (anyAttrMember != null)
  635. {
  636. if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
  637. {
  638. string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
  639. if (cond != null) WriteLineInd ("if (" + cond + ") {");
  640. string tmpVar = GetObTempVar ();
  641. WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
  642. WriteLineInd ("if (" + tmpVar + " != null) {");
  643. string tmpVar2 = GetObTempVar ();
  644. WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
  645. WriteLineInd ("if (" + tmpVar2 + ".NamespaceURI != xmlNamespace)");
  646. WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
  647. Unindent ();
  648. Unindent ();
  649. WriteLineUni ("}");
  650. if (cond != null) WriteLineUni ("}");
  651. WriteLine ("");
  652. GenerateEndHook ();
  653. }
  654. }
  655. ICollection attributes = map.AttributeMembers;
  656. if (attributes != null)
  657. {
  658. foreach (XmlTypeMapMemberAttribute attr in attributes)
  659. {
  660. if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
  661. string val = GenerateGetMemberValue (attr, ob, isValueList);
  662. string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
  663. if (cond != null) WriteLineInd ("if (" + cond + ") {");
  664. string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val, false);
  665. WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
  666. if (cond != null) WriteLineUni ("}");
  667. GenerateEndHook ();
  668. }
  669. WriteLine ("");
  670. }
  671. GenerateEndHook ();
  672. }
  673. if (!GenerateWriteHook (HookType.elements, xmlMapType))
  674. {
  675. ICollection members = map.ElementMembers;
  676. if (members != null)
  677. {
  678. foreach (XmlTypeMapMemberElement member in members)
  679. {
  680. if (GenerateWriteMemberHook (xmlMapType, member)) continue;
  681. string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
  682. if (cond != null) WriteLineInd ("if (" + cond + ") {");
  683. string memberValue = GenerateGetMemberValue (member, ob, isValueList);
  684. Type memType = member.GetType();
  685. if (memType == typeof(XmlTypeMapMemberList))
  686. {
  687. GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
  688. }
  689. else if (memType == typeof(XmlTypeMapMemberFlatList))
  690. {
  691. WriteLineInd ("if (" + memberValue + " != null) {");
  692. GenerateWriteListContent (ob, member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
  693. WriteLineUni ("}");
  694. }
  695. else if (memType == typeof(XmlTypeMapMemberAnyElement))
  696. {
  697. WriteLineInd ("if (" + memberValue + " != null) {");
  698. GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
  699. WriteLineUni ("}");
  700. }
  701. else if (memType == typeof(XmlTypeMapMemberAnyElement))
  702. {
  703. WriteLineInd ("if (" + memberValue + " != null) {");
  704. GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
  705. WriteLineUni ("}");
  706. }
  707. else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
  708. {
  709. // Ignore
  710. }
  711. else if (memType == typeof(XmlTypeMapMemberElement))
  712. {
  713. if (member.ElementInfo.Count == 1) {
  714. XmlTypeMapElementInfo elem = (XmlTypeMapElementInfo)member.ElementInfo[0];
  715. GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
  716. }
  717. else if (member.ChoiceMember != null)
  718. {
  719. string choiceValue = ob + ".@" + member.ChoiceMember;
  720. foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
  721. WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
  722. GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
  723. WriteLineUni ("}");
  724. }
  725. }
  726. else
  727. {
  728. // WriteLineInd ("if (" + memberValue + " == null) {");
  729. // GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
  730. // WriteLineUni ("}");
  731. bool first = true;
  732. foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
  733. {
  734. WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.CSharpFullName + ") {");
  735. GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
  736. WriteLineUni ("}");
  737. first = false;
  738. }
  739. }
  740. }
  741. else
  742. throw new InvalidOperationException ("Unknown member type");
  743. if (cond != null)
  744. WriteLineUni ("}");
  745. GenerateEndHook ();
  746. }
  747. }
  748. GenerateEndHook ();
  749. }
  750. }
  751. void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
  752. {
  753. switch (elem.TypeData.SchemaType)
  754. {
  755. case SchemaTypes.XmlNode:
  756. string elemName = elem.WrappedElement ? elem.ElementName : "";
  757. if (_format == SerializationFormat.Literal)
  758. WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
  759. else
  760. WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
  761. break;
  762. case SchemaTypes.Enum:
  763. case SchemaTypes.Primitive:
  764. if (_format == SerializationFormat.Literal)
  765. GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
  766. else
  767. GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
  768. break;
  769. case SchemaTypes.Array:
  770. WriteLineInd ("if (" + memberValue + " != null) {");
  771. if (elem.MappedType.MultiReferenceType) {
  772. WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
  773. RegisterReferencingMap (elem.MappedType);
  774. }
  775. else {
  776. WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
  777. GenerateWriteListContent (null, elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
  778. WriteMetCall ("WriteEndElement", memberValue);
  779. }
  780. WriteLineUni ("}");
  781. if (elem.IsNullable) {
  782. WriteLineInd ("else");
  783. if (_format == SerializationFormat.Literal)
  784. WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
  785. else
  786. WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
  787. Unindent ();
  788. }
  789. break;
  790. case SchemaTypes.Class:
  791. if (elem.MappedType.MultiReferenceType) {
  792. RegisterReferencingMap (elem.MappedType);
  793. if (elem.MappedType.TypeData.Type == typeof(object))
  794. WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
  795. else
  796. WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
  797. }
  798. else
  799. WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
  800. break;
  801. case SchemaTypes.XmlSerializable:
  802. WriteMetCall ("WriteSerializable", "(" + ToCSharpFullName (elem.MappedType.TypeData.Type) + ") " + memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
  803. break;
  804. default:
  805. throw new NotSupportedException ("Invalid value type");
  806. }
  807. }
  808. void GenerateWriteListElement (XmlTypeMapping typeMap, string ob)
  809. {
  810. if (_format == SerializationFormat.Encoded)
  811. {
  812. string n, ns;
  813. string itemCount = GenerateGetListCount (typeMap.TypeData, ob);
  814. GenerateGetArrayType ((ListMap) typeMap.ObjectMap, itemCount, out n, out ns);
  815. string arrayType;
  816. if (ns != string.Empty)
  817. arrayType = "FromXmlQualifiedName (new XmlQualifiedName(" + n + "," + ns + "))";
  818. else
  819. arrayType = GetLiteral (n);
  820. WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
  821. }
  822. GenerateWriteListContent (null, typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
  823. }
  824. void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
  825. {
  826. bool singleElement = (member.TypeData.Type == typeof (XmlElement));
  827. string var, var2;
  828. var = GetObTempVar ();
  829. if (singleElement)
  830. var2 = memberValue;
  831. else {
  832. var2 = GetObTempVar ();
  833. WriteLineInd ("foreach (object " + var2 + " in " + memberValue + ") {");
  834. }
  835. WriteLine ("XmlNode " + var + " = " + var2 + " as XmlNode;");
  836. WriteLine ("if (" + var + " == null && " + var2 + "!= null) throw new InvalidOperationException (\"A member with XmlAnyElementAttribute can only serialize and deserialize certain XmlNode types.\");");
  837. string elem = GetObTempVar ();
  838. WriteLine ("XmlNode " + elem + " = " + var + ";");
  839. WriteLineInd ("if (" + elem + " is XmlElement) {");
  840. if (!member.IsDefaultAny) {
  841. for (int n=0; n<member.ElementInfo.Count; n++) {
  842. XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)member.ElementInfo[n];
  843. string txt = "(" + elem + ".LocalName == " + GetLiteral(info.ElementName) + " && " + elem + ".NamespaceURI == " + GetLiteral(info.Namespace) + ")";
  844. if (n == member.ElementInfo.Count-1) txt += ") {";
  845. if (n == 0) WriteLineInd ("if (" + txt);
  846. else WriteLine ("|| " + txt);
  847. }
  848. }
  849. if (_format == SerializationFormat.Literal)
  850. WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
  851. else
  852. WriteLine ("WriteElementEncoded (" + elem + ", \"\", \"\", false, true);");
  853. if (!member.IsDefaultAny) {
  854. WriteLineUni ("}");
  855. WriteLineInd ("else");
  856. WriteLine ("throw CreateUnknownAnyElementException (" + elem + ".Name, " + elem + ".NamespaceURI);");
  857. Unindent ();
  858. }
  859. WriteLineUni ("}");
  860. WriteLine ("else " + elem + ".WriteTo (Writer);");
  861. if (!singleElement)
  862. WriteLineUni ("}");
  863. }
  864. void GenerateWritePrimitiveElement (XmlTypeMapping typeMap, string ob)
  865. {
  866. string strVal = GenerateGetStringValue (typeMap, typeMap.TypeData, ob, false);
  867. WriteLine ("Writer.WriteString (" + strVal + ");");
  868. }
  869. void GenerateWriteEnumElement (XmlTypeMapping typeMap, string ob)
  870. {
  871. string strVal = GenerateGetEnumXmlValue (typeMap, ob);
  872. WriteLine ("Writer.WriteString (" + strVal + ");");
  873. }
  874. string GenerateGetStringValue (XmlTypeMapping typeMap, TypeData type, string value, bool isNullable)
  875. {
  876. if (type.SchemaType == SchemaTypes.Array) {
  877. string str = GetStrTempVar ();
  878. WriteLine ("string " + str + " = null;");
  879. WriteLineInd ("if (" + value + " != null) {");
  880. string res = GenerateWriteListContent (null, typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
  881. WriteLine (str + " = " + res + ".ToString ().Trim ();");
  882. WriteLineUni ("}");
  883. return str;
  884. }
  885. else if (type.SchemaType == SchemaTypes.Enum) {
  886. if (isNullable)
  887. return "(" + value + ").HasValue ? " + GenerateGetEnumXmlValue (typeMap, "(" + value + ").Value") + " : null";
  888. else
  889. return GenerateGetEnumXmlValue (typeMap, value);
  890. }
  891. else if (type.Type == typeof (XmlQualifiedName))
  892. return "FromXmlQualifiedName (" + value + ")";
  893. else if (value == null)
  894. return null;
  895. else
  896. return XmlCustomFormatter.GenerateToXmlString (type, value);
  897. }
  898. string GenerateGetEnumXmlValue (XmlTypeMapping typeMap, string ob)
  899. {
  900. return GetGetEnumValueName (typeMap) + " (" + ob + ")";
  901. }
  902. string GenerateGetListCount (TypeData listType, string ob)
  903. {
  904. if (listType.Type.IsArray)
  905. return "ob.Length";
  906. else
  907. return "ob.Count";
  908. }
  909. void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns)
  910. {
  911. string arrayDim;
  912. if (itemCount != "") arrayDim = "";
  913. else arrayDim = "[]";
  914. XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0];
  915. if (info.TypeData.SchemaType == SchemaTypes.Array)
  916. {
  917. string nm;
  918. GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns);
  919. localName = nm + arrayDim;
  920. }
  921. else
  922. {
  923. if (info.MappedType != null)
  924. {
  925. localName = info.MappedType.XmlType + arrayDim;
  926. ns = info.MappedType.Namespace;
  927. }
  928. else
  929. {
  930. localName = info.TypeData.XmlType + arrayDim;
  931. ns = info.DataTypeNamespace;
  932. }
  933. }
  934. if (itemCount != "") {
  935. localName = "\"" + localName + "[\" + " + itemCount + " + \"]\"";
  936. ns = GetLiteral (ns);
  937. }
  938. }
  939. string GenerateWriteListContent (string container, TypeData listType, ListMap map, string ob, bool writeToString)
  940. {
  941. string targetString = null;
  942. if (writeToString)
  943. {
  944. targetString = GetStrTempVar ();
  945. WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();");
  946. }
  947. if (listType.Type.IsArray)
  948. {
  949. string itemVar = GetNumTempVar ();
  950. WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
  951. GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
  952. WriteLineUni ("}");
  953. }
  954. else if (typeof(ICollection).IsAssignableFrom (listType.Type))
  955. {
  956. string itemVar = GetNumTempVar ();
  957. WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
  958. GenerateListLoop (container, map, ob + "["+itemVar+"]", itemVar, listType.ListItemTypeData, targetString);
  959. WriteLineUni ("}");
  960. }
  961. else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
  962. {
  963. string itemVar = GetObTempVar ();
  964. WriteLineInd ("foreach (" + listType.ListItemTypeData.CSharpFullName + " " + itemVar + " in " + ob + ") {");
  965. GenerateListLoop (container, map, itemVar, null, listType.ListItemTypeData, targetString);
  966. WriteLineUni ("}");
  967. }
  968. else
  969. throw new Exception ("Unsupported collection type");
  970. return targetString;
  971. }
  972. void GenerateListLoop (string container, ListMap map, string item, string index, TypeData itemTypeData, string targetString)
  973. {
  974. bool multichoice = (map.ItemInfo.Count > 1);
  975. if (map.ChoiceMember != null && container != null && index != null) {
  976. WriteLineInd ("if ((" + container + ".@" + map.ChoiceMember + " == null) || (" + index + " >= " + container + ".@" + map.ChoiceMember + ".Length))");
  977. WriteLine ("throw CreateInvalidChoiceIdentifierValueException (" + container + ".GetType().ToString(), \"" + map.ChoiceMember + "\");");
  978. Unindent ();
  979. }
  980. if (multichoice)
  981. WriteLine ("if (((object)" + item + ") == null) { }");
  982. foreach (XmlTypeMapElementInfo info in map.ItemInfo)
  983. {
  984. if (map.ChoiceMember != null && multichoice)
  985. WriteLineInd ("else if (" + container + ".@" + map.ChoiceMember + "[" + index + "] == " + GetLiteral (info.ChoiceValue) + ") {");
  986. else if (multichoice)
  987. WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.CSharpFullName + ")) {");
  988. if (targetString == null)
  989. GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
  990. else
  991. {
  992. string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item), false);
  993. WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");");
  994. }
  995. if (multichoice)
  996. WriteLineUni ("}");
  997. }
  998. if (multichoice)
  999. WriteLine ("else throw CreateUnknownTypeException (" + item + ");");
  1000. }
  1001. void GenerateWritePrimitiveValueLiteral (string memberValue, string name, string ns, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
  1002. {
  1003. if (!wrapped) {
  1004. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, false);
  1005. WriteMetCall ("WriteValue", strVal);
  1006. }
  1007. else if (isNullable) {
  1008. if (typeData.Type == typeof(XmlQualifiedName))
  1009. WriteMetCall ("WriteNullableQualifiedNameLiteral", GetLiteral(name), GetLiteral(ns), memberValue);
  1010. else {
  1011. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, true);
  1012. WriteMetCall ("WriteNullableStringLiteral", GetLiteral(name), GetLiteral(ns), strVal);
  1013. }
  1014. }
  1015. else {
  1016. if (typeData.Type == typeof(XmlQualifiedName))
  1017. WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue);
  1018. else {
  1019. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, false);
  1020. WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal);
  1021. }
  1022. }
  1023. }
  1024. void GenerateWritePrimitiveValueEncoded (string memberValue, string name, string ns, XmlQualifiedName xsiType, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
  1025. {
  1026. if (!wrapped) {
  1027. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, false);
  1028. WriteMetCall ("WriteValue", strVal);
  1029. }
  1030. else if (isNullable) {
  1031. if (typeData.Type == typeof(XmlQualifiedName))
  1032. WriteMetCall ("WriteNullableQualifiedNameEncoded", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
  1033. else {
  1034. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, true);
  1035. WriteMetCall ("WriteNullableStringEncoded", GetLiteral(name), GetLiteral(ns), strVal, GetLiteral(xsiType));
  1036. }
  1037. }
  1038. else {
  1039. if (typeData.Type == typeof(XmlQualifiedName))
  1040. WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
  1041. else {
  1042. string strVal = GenerateGetStringValue (mappedType, typeData, memberValue, false);
  1043. WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal, GetLiteral(xsiType));
  1044. }
  1045. }
  1046. }
  1047. string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
  1048. {
  1049. if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.GlobalIndex + "]");
  1050. else return ob + ".@" + member.Name;
  1051. }
  1052. string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
  1053. {
  1054. if (isValueList) {
  1055. if (member.IsOptionalValueType)
  1056. return ob + ".Length > " + Math.Max (member.GlobalIndex, member.SpecifiedGlobalIndex) + " && " + GetCast (typeof(bool), ob + "[" + member.SpecifiedGlobalIndex + "]");
  1057. else
  1058. return ob + ".Length > " + member.GlobalIndex;
  1059. }
  1060. else if (member.DefaultValue != System.DBNull.Value) {
  1061. string mem = ob + ".@" + member.Name;
  1062. if (member.DefaultValue == null)
  1063. return mem + " != null";
  1064. else if (member.TypeData.SchemaType == SchemaTypes.Enum)
  1065. return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
  1066. else
  1067. return mem + " != " + GetLiteral (member.DefaultValue);
  1068. }
  1069. else if (member.IsOptionalValueType)
  1070. return ob + ".@" + member.Name + "Specified";
  1071. return null;
  1072. }
  1073. void GenerateWriteInitCallbacks ()
  1074. {
  1075. WriteLine ("protected override void InitCallbacks ()");
  1076. WriteLineInd ("{");
  1077. if (_format == SerializationFormat.Encoded)
  1078. {
  1079. foreach (XmlMapping xmap in _mapsToGenerate) {
  1080. XmlTypeMapping map = xmap as XmlTypeMapping;
  1081. if (map != null)
  1082. WriteMetCall ("AddWriteCallback", GetTypeOf(map.TypeData), GetLiteral(map.XmlType), GetLiteral(map.Namespace), "new XmlSerializationWriteCallback (" + GetWriteObjectCallbackName (map) + ")");
  1083. }
  1084. }
  1085. WriteLineUni ("}");
  1086. WriteLine ("");
  1087. if (_format == SerializationFormat.Encoded)
  1088. {
  1089. foreach (XmlTypeMapping xmap in _mapsToGenerate) {
  1090. XmlTypeMapping map = xmap as XmlTypeMapping;
  1091. if (map == null) continue;
  1092. if (map.TypeData.SchemaType == SchemaTypes.Enum)
  1093. WriteWriteEnumCallback (map);
  1094. else
  1095. WriteWriteObjectCallback (map);
  1096. }
  1097. }
  1098. }
  1099. void WriteWriteEnumCallback (XmlTypeMapping map)
  1100. {
  1101. WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
  1102. WriteLineInd ("{");
  1103. WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "true", "false");
  1104. WriteLineUni ("}");
  1105. WriteLine ("");
  1106. }
  1107. void WriteWriteObjectCallback (XmlTypeMapping map)
  1108. {
  1109. WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
  1110. WriteLineInd ("{");
  1111. WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "false", "false");
  1112. WriteLineUni ("}");
  1113. WriteLine ("");
  1114. }
  1115. #endregion
  1116. #region Reader Generation
  1117. //*******************************************************
  1118. // Reader generation
  1119. //
  1120. public void GenerateReader (string readerClassName, ArrayList maps)
  1121. {
  1122. if (_config == null || !_config.GenerateAsInternal)
  1123. WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
  1124. else
  1125. WriteLine ("internal class " + readerClassName + " : XmlSerializationReader");
  1126. WriteLineInd ("{");
  1127. // FromBinHexString() is not public, so use reflection here.
  1128. WriteLine ("static readonly System.Reflection.MethodInfo fromBinHexStringMethod = typeof (XmlConvert).GetMethod (\"FromBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (string)}, null);");
  1129. WriteLine ("static byte [] FromBinHexString (string input)");
  1130. WriteLineInd ("{");
  1131. WriteLine ("return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});");
  1132. WriteLineUni ("}");
  1133. _mapsToGenerate = new ArrayList ();
  1134. _fixupCallbacks = new ArrayList ();
  1135. InitHooks ();
  1136. for (int n=0; n<maps.Count; n++)
  1137. {
  1138. GenerationResult res = (GenerationResult) maps [n];
  1139. _typeMap = res.Mapping;
  1140. _format = _typeMap.Format;
  1141. _result = res;
  1142. GenerateReadRoot ();
  1143. }
  1144. for (int n=0; n<_mapsToGenerate.Count; n++)
  1145. {
  1146. XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
  1147. if (map == null) continue;
  1148. GenerateReadObject (map);
  1149. if (map.TypeData.SchemaType == SchemaTypes.Enum)
  1150. GenerateGetEnumValueMethod (map);
  1151. }
  1152. GenerateReadInitCallbacks ();
  1153. if (_format == SerializationFormat.Encoded)
  1154. {
  1155. GenerateFixupCallbacks ();
  1156. GenerateFillerCallbacks ();
  1157. }
  1158. WriteLineUni ("}");
  1159. UpdateGeneratedTypes (_mapsToGenerate);
  1160. }
  1161. void GenerateReadRoot ()
  1162. {
  1163. WriteLine ("public object " + _result.ReadMethodName + " ()");
  1164. WriteLineInd ("{");
  1165. WriteLine ("Reader.MoveToContent();");
  1166. if (_typeMap is XmlTypeMapping)
  1167. {
  1168. XmlTypeMapping typeMap = (XmlTypeMapping) _typeMap;
  1169. if (_format == SerializationFormat.Literal)
  1170. {
  1171. if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode) {
  1172. if (typeMap.TypeData.Type == typeof (XmlDocument))
  1173. WriteLine ("return ReadXmlDocument (false);");
  1174. else
  1175. WriteLine ("return ReadXmlNode (false);");
  1176. } else {
  1177. WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
  1178. WriteLine ("throw CreateUnknownNodeException();");
  1179. Unindent ();
  1180. WriteLine ("return " + GetReadObjectCall (typeMap, GetLiteral(typeMap.IsNullable), "true") + ";");
  1181. }
  1182. }
  1183. else
  1184. {
  1185. WriteLine ("object ob = null;");
  1186. WriteLine ("Reader.MoveToContent();");
  1187. WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
  1188. WriteLineInd ("{");
  1189. WriteLineInd ("if (Reader.LocalName == " + GetLiteral(typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
  1190. WriteLine ("ob = ReadReferencedElement();");
  1191. Unindent ();
  1192. WriteLineInd ("else ");
  1193. WriteLine ("throw CreateUnknownNodeException();"

Large files files are truncated, but you can click here to view the full file