mcs/class/System.Data/System.Data/CustomDataClassGenerator.cs

   1 //
   2 // Mono.Data.CustomDataClassGenerator
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // (C)2004 Novell Inc.
   8 //
   9 // API notes are the bottom of the source.
  10 //
  11 // This class is standalone testable (even under MS.NET) when compiled with
  12 // -d:DATACLASS_GENERATOR_STANDALONE .
  13 //
  14
  15 //
  16 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  17 //
  18 // Permission is hereby granted, free of charge, to any person obtaining
  19 // a copy of this software and associated documentation files (the
  20 // "Software"), to deal in the Software without restriction, including
  21 // without limitation the rights to use, copy, modify, merge, publish,
  22 // distribute, sublicense, and/or sell copies of the Software, and to
  23 // permit persons to whom the Software is furnished to do so, subject to
  24 // the following conditions:
  25 //
  26 // The above copyright notice and this permission notice shall be
  27 // included in all copies or substantial portions of the Software.
  28 //
  29 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  30 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  31 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  32 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  33 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  34 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  35 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  36 //
  37 using System;
  38 using System.Xml;
  39 using System.Data;
  40 using System.Collections;
  41 using System.CodeDom;
  42 using System.Globalization;
  43 using System.Text;
  44 using System.CodeDom.Compiler;
  45 using System.ComponentModel;
  46 using System.Runtime.Serialization;
  47
  48 // only for Driver
  49 using Microsoft.CSharp;
  50 using System.IO;
  51
  52 namespace System.Data
  53 {
  54
  55 #if DATACLASS_GENERATOR_STANDALONE
  56         public class Driver
  57         {
  58                 public static void Main (string [] args)
  59                 {
  60                         try {
  61                                 if (args.Length < 1) {
  62                                         Console.WriteLine ("mono dsgentest.exe filename");
  63                                         return;
  64                                 }
  65
  66                                 DataSet ds = new DataSet ();
  67                                 ds.ReadXml (args [0]);
  68                                 ICodeGenerator gen = new CSharpCodeProvider ().CreateGenerator ();
  69
  70                                 CodeNamespace cns = new CodeNamespace ("MyNamespace");
  71                                 TextWriter tw = new StreamWriter (Path.ChangeExtension (args [0], ".ms.cs"), false, Encoding.Default);
  72                                 TypedDataSetGenerator.Generate (ds, cns, gen);
  73                                 gen.GenerateCodeFromNamespace (cns, tw, null);
  74                                 tw.Close ();
  75
  76                                 cns = new CodeNamespace ("MyNamespace");
  77                                 tw = new StreamWriter (Path.ChangeExtension (args [0], ".mono.cs"), false, Encoding.Default);
  78                                 CustomDataClassGenerator.CreateDataSetClasses (ds, cns, gen, null);
  79                                 gen.GenerateCodeFromNamespace (cns, tw, null);
  80                                 tw.Close ();
  81                         } catch (Exception ex) {
  82                                 Console.WriteLine (ex);
  83                         }
  84                 }
  85         }
  86 #endif
  87
  88 #if DATACLASS_GENERATOR_STANDALONE
  89         public class CustomDataClassGenerator
  90 #else
  91         internal class CustomDataClassGenerator
  92 #endif
  93         {
  94                 public static void CreateDataSetClasses (DataSet ds,
  95                         CodeNamespace cns, ICodeGenerator gen,
  96                         ClassGeneratorOptions options)
  97                 {
  98                         new Generator (ds, cns, gen, options).Run ();
  99                 }
 100
 101                 public static string MakeSafeName (string name, ICodeGenerator codeGen)
 102                 {
 103                         if (name == null || codeGen == null)
 104                                 throw new NullReferenceException ();
 105
 106                         name = codeGen.CreateValidIdentifier (name);
 107
 108                         if (name.Length == 0)
 109                                 return "_";
 110
 111                         StringBuilder sb = null;
 112                         if (!Char.IsLetter (name, 0) && name [0] != '_') {
 113                                 sb = new StringBuilder ();
 114                                 sb.Append ('_');
 115                         }
 116
 117                         int start = 0;
 118                         for (int i = 0; i < name.Length; i++) {
 119                                 if (!Char.IsLetterOrDigit (name, i)) {
 120                                         if (sb == null)
 121                                                 sb = new StringBuilder ();
 122                                         sb.Append (name, start, i - start);
 123                                         sb.Append ('_');
 124                                         start = i + 1;
 125                                 }
 126                         }
 127
 128                         if (sb != null) {
 129                                 sb.Append (name, start, name.Length - start);
 130                                 return sb.ToString ();
 131                         }
 132                         else
 133                                 return name;
 134                 }
 135         }
 136
 137 #if DATACLASS_GENERATOR_STANDALONE
 138         public delegate string CodeNamingMethod (string source, ICodeGenerator gen);
 139 #else
 140         internal delegate string CodeNamingMethod (string source, ICodeGenerator gen);
 141 #endif
 142
 143 #if DATACLASS_GENERATOR_STANDALONE
 144         public class ClassGeneratorOptions
 145 #else
 146         internal class ClassGeneratorOptions
 147 #endif
 148         {
 149                 public bool MakeClassesInsideDataSet = true; // default = MS compatible
 150
 151                 public CodeNamingMethod CreateDataSetName;
 152                 public CodeNamingMethod CreateTableTypeName;
 153                 public CodeNamingMethod CreateTableMemberName;
 154                 public CodeNamingMethod CreateTableColumnName;
 155                 public CodeNamingMethod CreateColumnName;
 156                 public CodeNamingMethod CreateRowName;
 157                 public CodeNamingMethod CreateRelationName;
 158                 public CodeNamingMethod CreateTableDelegateName;
 159                 public CodeNamingMethod CreateEventArgsName;
 160
 161                 internal string DataSetName (string source, ICodeGenerator gen)
 162                 {
 163                         if (CreateDataSetName != null)
 164                                 return CreateDataSetName (source, gen);
 165                         else
 166                                 return CustomDataClassGenerator.MakeSafeName (source, gen);
 167                 }
 168
 169                 internal string TableTypeName (string source, ICodeGenerator gen)
 170                 {
 171                         if (CreateTableTypeName != null)
 172                                 return CreateTableTypeName (source, gen);
 173                         else
 174                                 return CustomDataClassGenerator.MakeSafeName (source, gen) + "DataTable";
 175                 }
 176
 177                 internal string TableMemberName (string source, ICodeGenerator gen)
 178                 {
 179                         if (CreateTableMemberName != null)
 180                                 return CreateTableMemberName (source, gen);
 181                         else
 182                                 return CustomDataClassGenerator.MakeSafeName (source, gen);
 183                 }
 184
 185                 internal string TableColName (string source, ICodeGenerator gen)
 186                 {
 187                         if (CreateTableColumnName != null)
 188                                 return CreateTableColumnName (source, gen);
 189                         else
 190                                 return CustomDataClassGenerator.MakeSafeName (source, gen);
 191                 }
 192
 193                 internal string TableDelegateName (string source, ICodeGenerator gen)
 194                 {
 195                         if (CreateTableDelegateName != null)
 196                                 return CreateTableDelegateName (source, gen);
 197                         else
 198                                 return CustomDataClassGenerator.MakeSafeName (source, gen) + "RowChangedEventHandler";
 199                 }
 200
 201                 internal string EventArgsName (string source, ICodeGenerator gen)
 202                 {
 203                         if (CreateEventArgsName != null)
 204                                 return CreateEventArgsName (source, gen);
 205                         else
 206                                 return CustomDataClassGenerator.MakeSafeName (source, gen) + "RowChangedEventArgs";
 207                 }
 208
 209                 internal string ColumnName (string source, ICodeGenerator gen)
 210                 {
 211                         if (CreateColumnName != null)
 212                                 return CreateColumnName (source, gen);
 213                         else
 214                                 return CustomDataClassGenerator.MakeSafeName (source, gen);
 215                 }
 216
 217                 internal string RowName (string source, ICodeGenerator gen)
 218                 {
 219                         if (CreateRowName != null)
 220                                 return CreateRowName (source, gen);
 221                         else
 222                                 return CustomDataClassGenerator.MakeSafeName (source, gen) + "Row";
 223                 }
 224
 225                 internal string RelationName (string source, ICodeGenerator gen)
 226                 {
 227                         if (CreateRelationName != null)
 228                                 return CreateRelationName (source, gen);
 229                         else
 230                                 return CustomDataClassGenerator.MakeSafeName (source, gen) + "Relation";
 231                 }
 232         }
 233
 234         internal class Generator
 235         {
 236                 static ClassGeneratorOptions DefaultOptions = new ClassGeneratorOptions ();
 237
 238                 DataSet ds;
 239                 CodeNamespace cns;
 240                 ClassGeneratorOptions opts;
 241                 ICodeGenerator gen;
 242
 243                 CodeTypeDeclaration dsType;
 244
 245                 public Generator (DataSet ds, CodeNamespace cns, ICodeGenerator gen, ClassGeneratorOptions options)
 246                 {
 247                         this.ds = ds;
 248                         this.cns = cns;
 249                         this.gen = gen;
 250                         this.opts = opts;
 251
 252                         if (opts == null)
 253                                 opts = DefaultOptions;
 254                 }
 255
 256                 public void Run ()
 257                 {
 258                         // using decls
 259                         cns.Imports.Add (new CodeNamespaceImport ("System"));
 260                         cns.Imports.Add (new CodeNamespaceImport ("System.Collections"));
 261                         cns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
 262                         cns.Imports.Add (new CodeNamespaceImport ("System.Data"));
 263                         cns.Imports.Add (new CodeNamespaceImport ("System.Runtime.Serialization"));
 264                         cns.Imports.Add (new CodeNamespaceImport ("System.Xml"));
 265
 266
 267                         CodeTypeDeclaration dsType = GenerateDataSetType ();
 268                         cns.Types.Add (dsType);
 269                         foreach (DataTable dt in ds.Tables) {
 270                                 // 1. table types ([foo]DataTable)
 271                                 // 2. row types ([foo]Row)
 272                                 // 3. delegates ([foo]RowChangedEventHandler)
 273                                 // 4. eventargs ([foo]RowChangeEventArgs)
 274
 275                                 CodeTypeDeclaration dtType = GenerateDataTableType (dt);
 276
 277                                 CodeTypeDeclaration dtRow = GenerateDataRowType (dt);
 278
 279                                 CodeTypeDelegate dtDelegate = new CodeTypeDelegate (opts.TableDelegateName (dt.TableName, gen));
 280                                 dtDelegate.Parameters.Add (Param (typeof (object), "o"));
 281                                 dtDelegate.Parameters.Add (Param (opts.EventArgsName (dt.TableName, gen), "e"));
 282
 283                                 CodeTypeDeclaration dtEventType = GenerateEventType (dt);
 284
 285                                 // Add types to either DataSet or CodeNamespace
 286                                 if (opts.MakeClassesInsideDataSet) {
 287                                         dsType.Members.Add (dtType);
 288                                         dsType.Members.Add (dtRow);
 289                                         dsType.Members.Add (dtDelegate);
 290                                         dsType.Members.Add (dtEventType);
 291                                 }
 292                                 else {
 293                                         cns.Types.Add (dtType);
 294                                         cns.Types.Add (dtRow);
 295                                         cns.Types.Add (dtDelegate);
 296                                         cns.Types.Add (dtEventType);
 297                                 }
 298                         }
 299                 }
 300
 301                 private CodeThisReferenceExpression This ()
 302                 {
 303                         return new CodeThisReferenceExpression ();
 304                 }
 305
 306                 private CodeBaseReferenceExpression Base ()
 307                 {
 308                         return new CodeBaseReferenceExpression ();
 309                 }
 310
 311                 private CodePrimitiveExpression Const (object value)
 312                 {
 313                         return new CodePrimitiveExpression (value);
 314                 }
 315
 316                 private CodeTypeReference TypeRef (Type t)
 317                 {
 318                         return new CodeTypeReference (t);
 319                 }
 320
 321                 private CodeTypeReference TypeRef (string name)
 322                 {
 323                         return new CodeTypeReference (name);
 324                 }
 325
 326                 private CodeParameterDeclarationExpression Param (string t, string name)
 327                 {
 328                         return new CodeParameterDeclarationExpression (t, name);
 329                 }
 330
 331                 private CodeParameterDeclarationExpression Param (Type t, string name)
 332                 {
 333                         return new CodeParameterDeclarationExpression (t, name);
 334                 }
 335
 336                 private CodeParameterDeclarationExpression Param (CodeTypeReference t, string name)
 337                 {
 338                         return new CodeParameterDeclarationExpression (t, name);
 339                 }
 340
 341                 private CodeArgumentReferenceExpression ParamRef (string name)
 342                 {
 343                         return new CodeArgumentReferenceExpression (name);
 344                 }
 345
 346                 private CodeCastExpression Cast (string t, CodeExpression exp)
 347                 {
 348                         return new CodeCastExpression (t, exp);
 349                 }
 350
 351                 private CodeCastExpression Cast (Type t, CodeExpression exp)
 352                 {
 353                         return new CodeCastExpression (t, exp);
 354                 }
 355
 356                 private CodeCastExpression Cast (CodeTypeReference t, CodeExpression exp)
 357                 {
 358                         return new CodeCastExpression (t, exp);
 359                 }
 360
 361                 private CodeExpression New (Type t, params CodeExpression [] parameters)
 362                 {
 363                         return new CodeObjectCreateExpression (t, parameters);
 364                 }
 365
 366                 private CodeExpression New (string t, params CodeExpression [] parameters)
 367                 {
 368                         return new CodeObjectCreateExpression (TypeRef (t), parameters);
 369                 }
 370
 371                 private CodeExpression NewArray (Type t, params CodeExpression [] parameters)
 372                 {
 373                         return new CodeArrayCreateExpression (t, parameters);
 374                 }
 375
 376                 private CodeVariableReferenceExpression Local (string name)
 377                 {
 378                         return new CodeVariableReferenceExpression (name);
 379                 }
 380
 381                 private CodeFieldReferenceExpression FieldRef (string name)
 382                 {
 383                         return new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), name);
 384                 }
 385
 386                 private CodeFieldReferenceExpression FieldRef (CodeExpression exp, string name)
 387                 {
 388                         return new CodeFieldReferenceExpression (exp, name);
 389                 }
 390
 391                 private CodePropertyReferenceExpression PropRef (string name)
 392                 {
 393                         return new CodePropertyReferenceExpression (new CodeThisReferenceExpression (), name);
 394                 }
 395
 396                 private CodePropertyReferenceExpression PropRef (CodeExpression target, string name)
 397                 {
 398                         return new CodePropertyReferenceExpression (target, name);
 399                 }
 400
 401                 private CodeIndexerExpression IndexerRef (CodeExpression target, CodeExpression parameters)
 402                 {
 403                         return new CodeIndexerExpression (target, parameters);
 404                 }
 405
 406                 private CodeIndexerExpression IndexerRef (CodeExpression param)
 407                 {
 408                         return new CodeIndexerExpression (new CodeThisReferenceExpression (), param);
 409                 }
 410
 411                 private CodeEventReferenceExpression EventRef (string name)
 412                 {
 413                         return new CodeEventReferenceExpression (new CodeThisReferenceExpression (), name);
 414                 }
 415
 416                 private CodeEventReferenceExpression EventRef (CodeExpression target, string name)
 417                 {
 418                         return new CodeEventReferenceExpression (target, name);
 419                 }
 420
 421                 private CodeMethodInvokeExpression MethodInvoke (string name, params CodeExpression [] parameters)
 422                 {
 423                         return new CodeMethodInvokeExpression (new CodeThisReferenceExpression (), name, parameters);
 424                 }
 425
 426                 private CodeMethodInvokeExpression MethodInvoke (CodeExpression target, string name, params CodeExpression [] parameters)
 427                 {
 428                         return new CodeMethodInvokeExpression (target, name, parameters);
 429                 }
 430
 431                 // note that this is "Identity" equality comparison
 432                 private CodeBinaryOperatorExpression Equals (CodeExpression exp1, CodeExpression exp2)
 433                 {
 434                         return new CodeBinaryOperatorExpression (exp1, CodeBinaryOperatorType.IdentityEquality, exp2);
 435                 }
 436
 437                 private CodeBinaryOperatorExpression Inequals (CodeExpression exp1, CodeExpression exp2)
 438                 {
 439                         return new CodeBinaryOperatorExpression (exp1, CodeBinaryOperatorType.IdentityInequality, exp2);
 440                 }
 441
 442                 private CodeTypeReferenceExpression TypeRefExp (Type t)
 443                 {
 444                         return new CodeTypeReferenceExpression (t);
 445                 }
 446
 447
 448                 private CodeExpressionStatement Eval (CodeExpression exp)
 449                 {
 450                         return new CodeExpressionStatement (exp);
 451                 }
 452
 453                 private CodeAssignStatement Let (CodeExpression exp, CodeExpression value)
 454                 {
 455                         return new CodeAssignStatement (exp, value);
 456                 }
 457
 458                 private CodeMethodReturnStatement Return (CodeExpression exp)
 459                 {
 460                         return new CodeMethodReturnStatement (exp);
 461                 }
 462
 463                 private CodeVariableDeclarationStatement VarDecl (Type t,
 464                         string name, CodeExpression init)
 465                 {
 466                         return new CodeVariableDeclarationStatement (t, name, init);
 467                 }
 468
 469                 private CodeVariableDeclarationStatement VarDecl (string t,
 470                         string name, CodeExpression init)
 471                 {
 472                         return new CodeVariableDeclarationStatement (t, name, init);
 473                 }
 474
 475                 private CodeCommentStatement Comment (string comment)
 476                 {
 477                         return new CodeCommentStatement (comment);
 478                 }
 479
 480                 private CodeThrowExceptionStatement Throw (CodeExpression exp)
 481                 {
 482                         return new CodeThrowExceptionStatement (exp);
 483                 }
 484
 485 #region DataSet class
 486
 487                 private CodeTypeDeclaration GenerateDataSetType ()
 488                 {
 489                         // Type
 490                         dsType = new CodeTypeDeclaration (opts.DataSetName (ds.DataSetName, gen));
 491                         dsType.BaseTypes.Add (TypeRef (typeof (DataSet)));
 492
 493                         // .ctor()
 494                         dsType.Members.Add (CreateDataSetDefaultCtor ());
 495                         // runtime serialization .ctor()
 496                         dsType.Members.Add (CreateDataSetSerializationCtor ());
 497
 498                         // Clone()
 499                         dsType.Members.Add (CreateDataSetCloneMethod (dsType));
 500
 501 // FIXME: I keep these methods out of the generated source right now.
 502 // It should be added after runtime serialization was implemented.
 503 /*
 504                         // ShouldSerializeTables()
 505                         dsType.Members.Add (CreateDataSetShouldSerializeTables ());
 506
 507                         // ShouldSerializeRelations()
 508                         dsType.Members.Add (CreateDataSetShouldSerializeRelations ());
 509
 510                         // ReadXmlSerializable()
 511                         dsType.Members.Add (CreateDataSetReadXmlSerializable ());
 512
 513                         // GetSchemaSerializable()
 514                         dsType.Members.Add (CreateDataSetGetSchemaSerializable ());
 515 */
 516                         dsType.Members.Add (CreateDataSetInitializeClass ());
 517                         dsType.Members.Add (CreateDataSetInitializeFields ());
 518                         dsType.Members.Add (CreateDataSetSchemaChanged ());
 519
 520                         // table class and members
 521                         foreach (DataTable table in ds.Tables)
 522                                 CreateDataSetTableMembers (dsType, table);
 523                         // relation class and members
 524                         foreach (DataRelation rel in ds.Relations)
 525                                 CreateDataSetRelationMembers (dsType, rel);
 526
 527                         return dsType;
 528                 }
 529
 530                 // Code:
 531                 // public Foo ()
 532                 // {
 533                 //   InitializeClass();
 534                 //   CollectionChangeEventHandler handler = new CollectionChangeEventHandler (SchemaChanged);
 535                 //   Tables.CollectionChanged += handler;
 536                 //   Relations.CollectionChanged += handler;
 537                 // }
 538                 private CodeConstructor CreateDataSetDefaultCtor ()
 539                 {
 540                         CodeConstructor ctor = new CodeConstructor ();
 541                         ctor.Attributes = MemberAttributes.Public;
 542                         // Code: InitializeClass().
 543                         ctor.Statements.Add (Eval (MethodInvoke ("InitializeClass")));
 544
 545                         // Code: CollectionChangedEventHandler handler = new CollectionChangeEventHandler (SchemeChanged);
 546                         CodeVariableDeclarationStatement stmt2 =
 547                                 VarDecl (
 548                                         typeof (CollectionChangeEventHandler),
 549                                         "handler",
 550                                         New (typeof (CollectionChangeEventHandler), FieldRef ("SchemaChanged")));
 551                         ctor.Statements.Add (stmt2);
 552
 553                         // Code: Tables.CollectionChanged += handler;
 554                         ctor.Statements.Add (
 555                                 new CodeAttachEventStatement (
 556                                         EventRef (
 557                                                 PropRef ("Tables"),
 558                                                 "CollectionChanged"),
 559                                         Local ("handler")));
 560
 561                         // Code: Relations.CollectionChanged += handler;
 562                         ctor.Statements.Add (
 563                                 new CodeAttachEventStatement (
 564                                         EventRef (
 565                                                 PropRef ("Relations"),
 566                                                 "CollectionChanged"),
 567                                         Local ("handler")));
 568
 569                         return ctor;
 570                 }
 571
 572                 // TODO: implement
 573
 574                 // Code:
 575                 // protected Foo (SerializationInfo info, StreamingContext ctx)
 576                 // {
 577                 //   throw new NotImplementedException ();
 578                 // }
 579                 private CodeConstructor CreateDataSetSerializationCtor ()
 580                 {
 581                         CodeConstructor ctor = new CodeConstructor ();
 582                         ctor.Attributes = MemberAttributes.Family;
 583                         ctor.Parameters.Add (Param (typeof (SerializationInfo), "info"));
 584                         ctor.Parameters.Add (Param (typeof (StreamingContext), "ctx"));
 585
 586                         // Code:
 587                         //  // TODO: implement
 588                         //  throw new NotImplementedException ();
 589                         ctor.Statements.Add (Comment ("TODO: implement"));
 590                         ctor.Statements.Add (Throw (New (typeof (NotImplementedException))));
 591
 592                         return ctor;
 593                 }
 594
 595                 // Code:
 596                 //  public override DataSet Clone()
 597                 //  {
 598                 //    [foo] set = ([foo]) base.Clone ();
 599                 //    set.InitializeFields ();
 600                 //    return set;
 601                 //  }
 602                 private CodeMemberMethod CreateDataSetCloneMethod (CodeTypeDeclaration dsType)
 603                 {
 604                         CodeMemberMethod m = new CodeMemberMethod ();
 605                         m.ReturnType = TypeRef (typeof (DataSet));
 606                         m.Attributes = MemberAttributes.Public | MemberAttributes.Override;
 607                         m.Name = "Clone";
 608                         // Code: [foo] set = ([foo]) base.Clone ();
 609                         CodeVariableReferenceExpression set = Local ("set");
 610                         m.Statements.Add (VarDecl (
 611                                         dsType.Name,
 612                                         "set",
 613                                         Cast (
 614                                                 dsType.Name,
 615                                                 MethodInvoke (Base (), "Clone"))));
 616                         m.Statements.Add (Eval (MethodInvoke (set, "InitializeFields")));
 617                         m.Statements.Add (Return (set));
 618                         return m;
 619                 }
 620
 621                 // Code:
 622                 // protected override bool ShouldSerializeTables ()
 623                 // {
 624                 //   return true; // it should be false
 625                 // }
 626                 private CodeMemberMethod CreateDataSetShouldSerializeTables ()
 627                 {
 628                         CodeMemberMethod m = new CodeMemberMethod ();
 629                         m.Name = "ShouldSerializeTables";
 630                         m.ReturnType = TypeRef (typeof (bool));
 631                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 632                         // FIXME: set "false" after serialization .ctor() implementation
 633                         m.Statements.Add (Return (Const (true)));
 634                         return m;
 635                 }
 636
 637                 // Code:
 638                 // protected override bool ShouldSerializeRelations ()
 639                 // {
 640                 //   return true; // it should be false
 641                 // }
 642                 private CodeMemberMethod CreateDataSetShouldSerializeRelations ()
 643                 {
 644                         CodeMemberMethod m = new CodeMemberMethod ();
 645                         m.Name = "ShouldSerializeRelations";
 646                         m.ReturnType = TypeRef (typeof (bool));
 647                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 648                         // FIXME: set "false" after serialization .ctor() implementation
 649                         m.Statements.Add (Return (Const (true)));
 650                         return m;
 651                 }
 652
 653                 // Code:
 654                 // protected override void ReadXmlSerializable()
 655                 // {
 656                 //   // TODO: implement
 657                 //   throw new NotImplementedException ();
 658                 // }
 659                 private CodeMemberMethod CreateDataSetReadXmlSerializable ()
 660                 {
 661                         CodeMemberMethod method = new CodeMemberMethod ();
 662                         method.Name = "ReadXmlSerializable";
 663                         method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 664                         method.Parameters.Add (Param (TypeRef (typeof (XmlReader)), "reader"));
 665                         // TODO: implemnet
 666                         method.Statements.Add (Comment ("TODO: implement"));
 667                         // Hey, how can I specify the constructor to invoke chained ctor with an empty parameter list!?
 668                         method.Statements.Add (Throw (New (typeof (NotImplementedException))));
 669                         return method;
 670                 }
 671
 672                 private CodeMemberMethod CreateDataSetInitializeClass ()
 673                 {
 674                         CodeMemberMethod m = new CodeMemberMethod ();
 675                         m.Name = "InitializeClass";
 676                         m.Attributes = MemberAttributes.Assembly;
 677
 678                         // dataset properties
 679                         m.Statements.Add (Let (PropRef ("DataSetName"), Const (ds.DataSetName)));
 680                         m.Statements.Add (Let (PropRef ("Prefix"), Const (ds.Prefix)));
 681                         m.Statements.Add (Let (PropRef ("Namespace"), Const (ds.Namespace)));
 682                         m.Statements.Add (Let (PropRef ("Locale"), New (typeof (CultureInfo), Const (ds.Locale.Name))));
 683                         m.Statements.Add (Let (PropRef ("CaseSensitive"), Const (ds.CaseSensitive)));
 684                         m.Statements.Add (Let (PropRef ("EnforceConstraints"), Const (ds.EnforceConstraints)));
 685
 686                         // table
 687                         foreach (DataTable dt in ds.Tables) {
 688                                 string tableFieldName = "__table" + opts.TableMemberName (dt.TableName, gen);
 689                                 string tableTypeName = opts.TableTypeName (dt.TableName, gen);
 690                                 m.Statements.Add (Let (FieldRef (tableFieldName), New (tableTypeName)));
 691                                 m.Statements.Add (Eval (MethodInvoke (PropRef ("Tables"), "Add", FieldRef (tableFieldName))));
 692                         }
 693
 694                         bool fkcExists = false;
 695                         bool ucExists = false;
 696                         foreach (DataTable dt in ds.Tables) {
 697                                 string tname = "__table" + opts.TableMemberName (dt.TableName, gen);
 698                                 foreach (Constraint c in dt.Constraints) {
 699                                         UniqueConstraint uc = c as UniqueConstraint;
 700                                         if (uc != null) {
 701                                                 if (!ucExists) {
 702                                                         m.Statements.Add (VarDecl (typeof (UniqueConstraint), "uc", null));
 703                                                         ucExists = true;
 704                                                 }
 705                                                 CreateUniqueKeyStatements (m, uc, tname);
 706                                                 continue;
 707                                         }
 708                                         ForeignKeyConstraint fkc = c as ForeignKeyConstraint;
 709                                         if (fkc != null) {
 710                                                 if (!fkcExists) {
 711                                                         m.Statements.Add (VarDecl (typeof (ForeignKeyConstraint), "fkc", null));
 712                                                         fkcExists = true;
 713                                                 }
 714                                                 CreateForeignKeyStatements (m, fkc, tname);
 715                                         }
 716                                         // What if other cases? dunno. Just ignore ;-)
 717                                 }
 718                         }
 719                         foreach (DataRelation rel in ds.Relations) {
 720                                 string relName = opts.RelationName (rel.RelationName, gen);
 721                                 ArrayList pcols = new ArrayList ();
 722                                 foreach (DataColumn pcol in rel.ParentColumns)
 723                                         pcols.Add (IndexerRef (PropRef (FieldRef ("__table" + opts.TableMemberName (rel.ParentTable.TableName, gen)), "Columns"), Const (pcol.ColumnName)));
 724
 725                                 ArrayList ccols = new ArrayList ();
 726                                 foreach (DataColumn ccol in rel.ChildColumns)
 727                                         ccols.Add (IndexerRef (PropRef (FieldRef ("__table" + opts.TableMemberName (rel.ChildTable.TableName, gen)), "Columns"), Const (ccol.ColumnName)));
 728
 729                                 // relation field
 730                                 string fieldName = "__relation" + relName;
 731                                 m.Statements.Add (Let (FieldRef (fieldName), New (typeof (DataRelation),
 732                                         Const (rel.RelationName),
 733                                         NewArray (typeof (DataColumn), pcols.ToArray (typeof (CodeExpression)) as CodeExpression []),
 734                                         NewArray (typeof (DataColumn), ccols.ToArray (typeof (CodeExpression)) as CodeExpression []),
 735                                         Const (false)
 736                                         )));
 737                                 m.Statements.Add (Let (PropRef (FieldRef (fieldName), "Nested"), Const (rel.Nested)));
 738                         }
 739
 740                         return m;
 741                 }
 742
 743                 private void CreateUniqueKeyStatements (CodeMemberMethod m, UniqueConstraint uc, string tableField)
 744                 {
 745                         ArrayList al = new ArrayList ();
 746                         foreach (DataColumn col in uc.Columns)
 747                                 al.Add (IndexerRef (PropRef (FieldRef (tableField), "Columns"), Const (col.ColumnName)));
 748
 749                         m.Statements.Add (Let (Local ("uc"), New (
 750                                 typeof (UniqueConstraint),
 751                                 Const (uc.ConstraintName),
 752                                 NewArray (
 753                                         typeof (DataColumn),
 754                                         al.ToArray (typeof (CodeExpression)) as CodeExpression []),
 755                                 Const (uc.IsPrimaryKey))));
 756                         m.Statements.Add (MethodInvoke (PropRef (FieldRef (tableField), "Constraints"), "Add", Local ("uc")));
 757                 }
 758
 759                 private void CreateForeignKeyStatements (CodeMemberMethod m,ForeignKeyConstraint fkc, string tableField)
 760                 {
 761                         ArrayList pcols = new ArrayList ();
 762                         foreach (DataColumn col in fkc.Columns)
 763                                 pcols.Add (IndexerRef (PropRef (FieldRef (tableField), "Columns"), Const (col.ColumnName)));
 764
 765                         ArrayList ccols = new ArrayList ();
 766                         foreach (DataColumn col in fkc.RelatedColumns)
 767                                 pcols.Add (IndexerRef (PropRef (FieldRef (tableField), "Columns"), Const (col.ColumnName)));
 768
 769                         m.Statements.Add (Let (Local ("fkc"), New (
 770                                 typeof (ForeignKeyConstraint),
 771                                 Const (fkc.ConstraintName),
 772                                 NewArray (
 773                                         typeof (DataColumn),
 774                                         pcols.ToArray (typeof (CodeExpression)) as CodeExpression []),
 775                                 NewArray (
 776                                         typeof (DataColumn),
 777                                         ccols.ToArray (typeof (CodeExpression)) as CodeExpression []))));
 778
 779                         m.Statements.Add (Let (
 780                                 PropRef (Local ("fkc"), "AcceptRejectRule"),
 781                                 FieldRef (TypeRefExp (typeof (AcceptRejectRule)), Enum.GetName (typeof (AcceptRejectRule), fkc.AcceptRejectRule))));
 782                         m.Statements.Add (Let (
 783                                 PropRef (Local ("fkc"), "DeleteRule"),
 784                                 FieldRef (TypeRefExp (typeof (Rule)), Enum.GetName (typeof (Rule), fkc.DeleteRule))));
 785                         m.Statements.Add (Let (
 786                                 PropRef (Local ("fkc"), "UpdateRule"),
 787                                 FieldRef (TypeRefExp (typeof (Rule)), Enum.GetName (typeof (Rule), fkc.UpdateRule))));
 788
 789                         m.Statements.Add (MethodInvoke (PropRef (FieldRef (tableField), "Constraints"), "Add", Local ("fkc")));
 790                 }
 791
 792                 private CodeMemberMethod CreateDataSetInitializeFields ()
 793                 {
 794                         CodeMemberMethod m = new CodeMemberMethod ();
 795                         m.Attributes = MemberAttributes.Assembly;
 796                         m.Name = "InitializeFields";
 797
 798                         foreach (DataTable dt in ds.Tables)
 799                                 m.Statements.Add (Eval (MethodInvoke (FieldRef ("__table" + opts.TableMemberName (dt.TableName, gen)), "InitializeFields")));
 800
 801                         foreach (DataRelation rel in ds.Relations)
 802                                 m.Statements.Add (Let (FieldRef ("__relation" + opts.RelationName (rel.RelationName, gen)), IndexerRef (PropRef ("Relations"), Const (rel.RelationName))));
 803
 804                         return m;
 805                 }
 806
 807                 private CodeMemberMethod CreateDataSetSchemaChanged ()
 808                 {
 809                         CodeMemberMethod m = new CodeMemberMethod ();
 810                         m.Name = "SchemaChanged";
 811                         m.Parameters.Add (Param (typeof (object), "sender"));
 812                         m.Parameters.Add (Param (typeof (CollectionChangeEventArgs), "e"));
 813
 814                         m.Statements.Add (
 815                                 new CodeConditionStatement (
 816                                         Equals (
 817                                                 PropRef (ParamRef ("e"), "Action"),
 818                                                 FieldRef (TypeRefExp (typeof (CollectionChangeAction)), "Remove")),
 819                                         new CodeStatement [] { Eval (MethodInvoke ("InitializeFields")) },
 820                                         new CodeStatement [] {}));
 821                         return m;
 822                 }
 823
 824                 private void CreateDataSetTableMembers (CodeTypeDeclaration dsType, DataTable table)
 825                 {
 826                         string tableTypeName = opts.TableTypeName (table.TableName, gen);
 827                         string tableVarName = opts.TableMemberName (table.TableName, gen);
 828
 829                         CodeMemberField privTable = new CodeMemberField ();
 830                         privTable.Type = TypeRef (tableTypeName);
 831                         privTable.Name = "__table" + tableVarName;
 832                         dsType.Members.Add (privTable);
 833
 834                         CodeMemberProperty pubTable = new CodeMemberProperty ();
 835                         pubTable.Type = TypeRef (tableTypeName);
 836                         pubTable.Attributes = MemberAttributes.Public;
 837                         pubTable.Name = tableVarName;
 838                         pubTable.HasSet = false;
 839                         // Code: return __table[foo];
 840                         pubTable.GetStatements.Add (Return (FieldRef ("__table" + tableVarName)));
 841
 842                         dsType.Members.Add (pubTable);
 843
 844                 }
 845
 846                 private void CreateDataSetRelationMembers (CodeTypeDeclaration dsType, DataRelation relation)
 847                 {
 848                         string relName = opts.RelationName (relation.RelationName, gen);
 849                         string fieldName = "__relation" + relName;
 850
 851                         CodeMemberField field = new CodeMemberField ();
 852                         field.Type = TypeRef (typeof (DataRelation));
 853                         field.Name = fieldName;
 854                         dsType.Members.Add (field);
 855
 856                         // This is not supported in MS.NET
 857                         CodeMemberProperty prop = new CodeMemberProperty ();
 858                         prop.Type = TypeRef (typeof (DataRelation));
 859                         prop.Attributes = MemberAttributes.Public;
 860                         prop.Name = relName;
 861                         prop.HasSet = false;
 862                         // Code: return __relation[foo_bar];
 863                         prop.GetStatements.Add (Return (FieldRef (fieldName)));
 864                         dsType.Members.Add (prop);
 865                 }
 866
 867 #endregion
 868
 869
 870
 871 #region DataTable class
 872
 873                 private CodeTypeDeclaration GenerateDataTableType (DataTable dt)
 874                 {
 875                         CodeTypeDeclaration t = new CodeTypeDeclaration ();
 876                         t.Name = opts.TableTypeName (dt.TableName, gen);
 877                         t.BaseTypes.Add (TypeRef (typeof (DataTable)));
 878                         t.BaseTypes.Add (TypeRef (typeof (IEnumerable)));
 879
 880                         t.Members.Add (CreateTableCtor1 (dt));
 881                         t.Members.Add (CreateTableCtor2 (dt));
 882
 883                         t.Members.Add (CreateTableCount (dt));
 884                         t.Members.Add (CreateTableIndexer (dt));
 885
 886                         t.Members.Add (CreateTableInitializeClass (dt));
 887                         t.Members.Add (CreateTableInitializeFields (dt));
 888
 889                         t.Members.Add (CreateTableGetEnumerator (dt));
 890                         t.Members.Add (CreateTableClone (dt));
 891                         t.Members.Add (CreateTableCreateInstance (dt));
 892
 893                         t.Members.Add (CreateTableAddRow1 (dt));
 894                         t.Members.Add (CreateTableAddRow2 (dt));
 895                         t.Members.Add (CreateTableNewRow (dt));
 896                         t.Members.Add (CreateTableNewRowFromBuilder (dt));
 897                         t.Members.Add (CreateTableRemoveRow (dt));
 898                         t.Members.Add (CreateTableGetRowType (dt));
 899
 900                         t.Members.Add (CreateTableEventStarter (dt, "Changing"));
 901                         t.Members.Add (CreateTableEventStarter (dt, "Changed"));
 902                         t.Members.Add (CreateTableEventStarter (dt, "Deleting"));
 903                         t.Members.Add (CreateTableEventStarter (dt, "Deleted"));
 904
 905                         // events
 906                         t.Members.Add (CreateTableEvent (dt, "RowChanging"));
 907                         t.Members.Add (CreateTableEvent (dt, "RowChanged"));
 908                         t.Members.Add (CreateTableEvent (dt, "RowDeleting"));
 909                         t.Members.Add (CreateTableEvent (dt, "RowDeleted"));
 910
 911                         // column members
 912                         foreach (DataColumn col in dt.Columns) {
 913                                 t.Members.Add (CreateTableColumnField (dt, col));
 914                                 t.Members.Add (CreateTableColumnProperty (dt, col));
 915                         }
 916
 917                         return t;
 918                 }
 919
 920                 // Code:
 921                 //  internal [foo]DataTable () : base ("[foo]")
 922                 //  {
 923                 //    InitializeClass ();
 924                 //  }
 925                 private CodeConstructor CreateTableCtor1 (DataTable dt)
 926                 {
 927                         CodeConstructor c = new CodeConstructor ();
 928                         c.Attributes = MemberAttributes.Assembly;
 929                         c.BaseConstructorArgs.Add (Const (dt.TableName));
 930                         c.Statements.Add (Eval (MethodInvoke ("InitializeClass")));
 931                         c.Statements.Add (Eval (MethodInvoke ("InitializeFields")));
 932                         return c;
 933                 }
 934
 935                 // Code:
 936                 //  internal [foo]DataTable (DataTable table) : base (table.TableName)
 937                 //  {
 938                 //    // TODO: implement
 939                 //    throw new NotImplementedException ();
 940                 //  }
 941                 private CodeConstructor CreateTableCtor2 (DataTable dt)
 942                 {
 943                         CodeConstructor c = new CodeConstructor ();
 944                         c.Attributes = MemberAttributes.Assembly;
 945                         c.Parameters.Add (Param (typeof (DataTable), "table"));
 946                         c.BaseConstructorArgs.Add (PropRef (ParamRef ("table"), "TableName"));
 947                         // TODO: implement
 948                         c.Statements.Add (Comment ("TODO: implement"));
 949                         c.Statements.Add (Throw (New (typeof (NotImplementedException))));
 950                         return c;
 951                 }
 952
 953                 private CodeMemberMethod CreateTableInitializeClass (DataTable dt)
 954                 {
 955                         CodeMemberMethod m = new CodeMemberMethod ();
 956                         m.Name = "InitializeClass";
 957                         foreach (DataColumn col in dt.Columns) {
 958                                 m.Statements.Add (Eval (MethodInvoke (
 959                                         PropRef ("Columns"),
 960                                         "Add",
 961                                         New (typeof (DataColumn),
 962                                                 Const (col.ColumnName),
 963                                                 new CodeTypeOfExpression (col.DataType)
 964                                                 ))));
 965                         }
 966                         return m;
 967                 }
 968
 969                 private CodeMemberMethod CreateTableInitializeFields (DataTable dt)
 970                 {
 971                         CodeMemberMethod m = new CodeMemberMethod ();
 972                         m.Name = "InitializeFields";
 973                         m.Attributes = MemberAttributes.Assembly;
 974                         foreach (DataColumn col in dt.Columns)
 975                                 m.Statements.Add (Let (FieldRef ("__column" + opts.TableColName (col.ColumnName, gen)), IndexerRef (PropRef ("Columns"), Const (col.ColumnName))));
 976                         return m;
 977                 }
 978
 979                 private CodeMemberMethod CreateTableClone (DataTable dt)
 980                 {
 981                         CodeMemberMethod m = new CodeMemberMethod ();
 982                         m.Name = "Clone";
 983                         m.Attributes = MemberAttributes.Public | MemberAttributes.Override;
 984                         m.ReturnType = TypeRef (typeof (DataTable));
 985                         string typeName = opts.TableTypeName (dt.TableName, gen);
 986                         m.Statements.Add (
 987                                 VarDecl (typeName, "t", Cast (typeName, MethodInvoke (Base (), "Clone"))));
 988                         m.Statements.Add (Eval (MethodInvoke (Local ("t"), "InitializeFields")));
 989                         m.Statements.Add (Return (Local ("t")));
 990                         return m;
 991                 }
 992
 993                 private CodeMemberMethod CreateTableGetEnumerator (DataTable dt)
 994                 {
 995                         CodeMemberMethod m = new CodeMemberMethod ();
 996                         m.Name = "GetEnumerator";
 997                         m.Attributes = MemberAttributes.Public;
 998                         m.ReturnType = TypeRef (typeof (IEnumerator));
 999                         m.Statements.Add (Return (MethodInvoke (PropRef ("Rows"), "GetEnumerator")));
1000                         return m;
1001                 }
1002
1003                 private CodeMemberMethod CreateTableCreateInstance (DataTable dt)
1004                 {
1005                         CodeMemberMethod m = new CodeMemberMethod ();
1006                         m.Name = "CreateInstance";
1007                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
1008                         m.ReturnType = TypeRef (typeof (DataTable));
1009                         m.Statements.Add (Return (New (opts.TableTypeName (dt.TableName, gen))));
1010                         return m;
1011                 }
1012
1013                 private CodeMemberField CreateTableColumnField (DataTable dt, DataColumn col)
1014                 {
1015                         CodeMemberField f = new CodeMemberField ();
1016                         f.Name = "__column" + opts.ColumnName (col.ColumnName, gen);
1017                         f.Type = TypeRef (typeof (DataColumn));
1018                         return f;
1019                 }
1020
1021                 private CodeMemberProperty CreateTableColumnProperty (DataTable dt, DataColumn col)
1022                 {
1023                         string name = opts.ColumnName (col.ColumnName, gen);
1024                         CodeMemberProperty p = new CodeMemberProperty ();
1025                         p.Name = name + "Column";
1026                         p.Attributes = MemberAttributes.Assembly;
1027                         p.Type = TypeRef (typeof (DataColumn));
1028                         p.HasSet = false;
1029                         p.GetStatements.Add (Return (FieldRef ("__column" + name)));
1030                         return p;
1031                 }
1032
1033                 private CodeMemberProperty CreateTableCount (DataTable dt)
1034                 {
1035                         CodeMemberProperty p = new CodeMemberProperty ();
1036                         p.Name = "Count";
1037                         p.Attributes = MemberAttributes.Public;
1038                         p.Type = TypeRef (typeof (int));
1039                         p.HasSet = false;
1040                         p.GetStatements.Add (Return (PropRef (PropRef ("Rows"), "Count")));
1041                         return p;
1042                 }
1043
1044                 private CodeMemberProperty CreateTableIndexer (DataTable dt)
1045                 {
1046                         string rowName = opts.RowName (dt.TableName, gen);
1047                         CodeMemberProperty ix = new CodeMemberProperty ();
1048                         ix.Name = "Item"; // indexer
1049                         ix.Attributes = MemberAttributes.Public;
1050                         ix.Type = TypeRef (rowName);
1051                         ix.Parameters.Add (Param (typeof (int), "i"));
1052                         ix.HasSet = false;
1053                         ix.GetStatements.Add (Return (Cast (rowName, IndexerRef (PropRef ("Rows"), ParamRef ("i")))));
1054                         return ix;
1055                 }
1056
1057                 private CodeMemberMethod CreateTableAddRow1 (DataTable dt)
1058                 {
1059                         CodeMemberMethod m = new CodeMemberMethod ();
1060                         string rowType = opts.RowName (dt.TableName, gen);
1061                         m.Name = "Add" + rowType;
1062                         m.Attributes = MemberAttributes.Public;
1063                         m.Parameters.Add (Param (TypeRef (rowType), "row"));
1064                         m.Statements.Add (Eval (MethodInvoke (PropRef ("Rows"), "Add", ParamRef ("row"))));
1065                         return m;
1066                 }
1067
1068                 private CodeMemberMethod CreateTableAddRow2 (DataTable dt)
1069                 {
1070                         CodeMemberMethod m = new CodeMemberMethod ();
1071                         string rowType = opts.RowName (dt.TableName, gen);
1072                         m.Name = "Add" + rowType;
1073                         m.ReturnType = TypeRef (rowType);
1074                         m.Attributes = MemberAttributes.Public;
1075
1076                         m.Statements.Add (VarDecl (rowType, "row", MethodInvoke ("New" + rowType)));
1077
1078                         foreach (DataColumn col in dt.Columns) {
1079                                 if (col.ColumnMapping == MappingType.Hidden) {
1080                                         foreach (DataRelation r in dt.DataSet.Relations) {
1081                                                 if (r.ChildTable == dt) {
1082                                                         // parameter
1083                                                         string paramType = opts.RowName (r.ParentTable.TableName, gen);
1084                                                         string paramName = paramType;
1085                                                         m.Parameters.Add (Param (paramType, paramName));
1086                                                         // CODE: SetParentRow (fooRow, DataSet.Relations ["foo_bar"]);
1087                                                         m.Statements.Add (Eval (MethodInvoke (Local ("row"), "SetParentRow", ParamRef (paramName), IndexerRef (PropRef (PropRef ("DataSet"), "Relations"), Const (r.RelationName)))));
1088                                                         break;
1089                                                 }
1090                                         }
1091                                 }
1092                                 else {
1093                                         // parameter
1094                                         string paramName = opts.ColumnName (col.ColumnName, gen);
1095                                         m.Parameters.Add (Param (col.DataType, paramName));
1096                                         // row ["foo"] = foo;
1097                                         m.Statements.Add (Let (IndexerRef (Local ("row"), Const (paramName)), ParamRef (paramName)));
1098                                 }
1099                         }
1100
1101                         // Rows.Add (row);
1102                         m.Statements.Add (MethodInvoke (PropRef ("Rows"), "Add", Local ("row")));
1103                         m.Statements.Add (Return (Local ("row")));
1104
1105                         return m;
1106                 }
1107
1108                 private CodeMemberMethod CreateTableNewRow (DataTable dt)
1109                 {
1110                         CodeMemberMethod m = new CodeMemberMethod ();
1111                         string rowType = opts.RowName (dt.TableName, gen);
1112                         m.Name = "New" + rowType;
1113                         m.ReturnType = TypeRef (rowType);
1114                         m.Attributes = MemberAttributes.Public;
1115                         m.Statements.Add (Return (Cast (rowType, MethodInvoke ("NewRow"))));
1116                         return m;
1117                 }
1118
1119                 private CodeMemberMethod CreateTableNewRowFromBuilder (DataTable dt)
1120                 {
1121                         CodeMemberMethod m = new CodeMemberMethod ();
1122                         m.Name = "NewRowFromBuilder";
1123                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
1124                         m.ReturnType = TypeRef (typeof (DataRow));
1125                         m.Parameters.Add (Param (typeof (DataRowBuilder), "builder"));
1126                         m.Statements.Add (Return (New (opts.RowName (dt.TableName, gen), ParamRef ("builder"))));
1127                         return m;
1128                 }
1129
1130                 private CodeMemberMethod CreateTableRemoveRow (DataTable dt)
1131                 {
1132                         CodeMemberMethod m = new CodeMemberMethod ();
1133                         string rowType = opts.RowName (dt.TableName, gen);
1134                         m.Name = "Remove" + rowType;
1135                         m.Attributes = MemberAttributes.Public;
1136                         m.Parameters.Add (Param (TypeRef (rowType), "row"));
1137                         m.Statements.Add (Eval (MethodInvoke (PropRef ("Rows"), "Remove", ParamRef ("row"))));
1138                         return m;
1139                 }
1140
1141                 private CodeMemberMethod CreateTableGetRowType (DataTable dt)
1142                 {
1143                         CodeMemberMethod m = new CodeMemberMethod ();
1144                         m.Name = "GetRowType";
1145                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
1146                         m.ReturnType = TypeRef (typeof (Type));
1147                         m.Statements.Add (Return (new CodeTypeOfExpression (opts.RowName (dt.TableName, gen))));
1148                         return m;
1149                 }
1150
1151                 private CodeMemberMethod CreateTableEventStarter (DataTable dt, string type)
1152                 {
1153                         CodeMemberMethod m = new CodeMemberMethod ();
1154                         m.Name = "OnRow" + type;
1155                         m.Attributes = MemberAttributes.Family | MemberAttributes.Override;
1156                         m.Parameters.Add (Param (typeof (DataRowChangeEventArgs), "e"));
1157
1158                         m.Statements.Add (Eval (MethodInvoke (
1159                                         Base (),
1160                                         m.Name,
1161                                         ParamRef ("e"))));
1162                         string eventName = opts.TableMemberName (dt.TableName, gen) + "Row" + type;
1163                         CodeStatement trueStmt = Eval (
1164                                 MethodInvoke (
1165                                         eventName,
1166                                         This (),
1167                                         New (
1168                                                 opts.EventArgsName (dt.TableName, gen),
1169                                                 Cast (opts.RowName (dt.TableName, gen), PropRef (ParamRef ("e"), "Row")),
1170                                                 PropRef (ParamRef ("e"), "Action"))));
1171
1172                         m.Statements.Add (
1173                                 new CodeConditionStatement (
1174                                         Inequals (EventRef (eventName), Const (null)),
1175                                         new CodeStatement [] {trueStmt},
1176                                         new CodeStatement [] {}));
1177
1178                         return m;
1179                 }
1180
1181                 private CodeMemberEvent CreateTableEvent (DataTable dt, string nameSuffix)
1182                 {
1183                         CodeMemberEvent cme = new CodeMemberEvent ();
1184                         cme.Attributes = MemberAttributes.Public;
1185                         cme.Name = opts.TableMemberName (dt.TableName, gen) + nameSuffix;
1186                         cme.Type = TypeRef (opts.TableDelegateName (dt.TableName, gen));
1187                         return cme;
1188                 }
1189
1190 #endregion
1191
1192
1193
1194 #region Row class
1195
1196                 public CodeTypeDeclaration GenerateDataRowType (DataTable dt)
1197                 {
1198                         CodeTypeDeclaration t = new CodeTypeDeclaration ();
1199                         t.Name = opts.RowName (dt.TableName, gen);
1200                         t.BaseTypes.Add (TypeRef (typeof (DataRow)));
1201
1202                         t.Members.Add (CreateRowCtor (dt));
1203
1204                         t.Members.Add (CreateRowTableField (dt));
1205
1206                         foreach (DataColumn col in dt.Columns) {
1207                                 if (col.ColumnMapping != MappingType.Hidden) {
1208                                         t.Members.Add (CreateRowColumnProperty (dt, col));
1209                                         t.Members.Add (CreateRowColumnIsNull (dt, col));
1210                                         t.Members.Add (CreateRowColumnSetNull (dt, col));
1211                                 }
1212                         }
1213
1214                         foreach (DataRelation rel in dt.ParentRelations)
1215                                 t.Members.Add (CreateRowParentRowProperty (dt, rel));
1216                         foreach (DataRelation rel in dt.ChildRelations)
1217                                 t.Members.Add (CreateRowGetChildRows (dt, rel));
1218
1219                         return t;
1220                 }
1221
1222                 private CodeConstructor CreateRowCtor (DataTable dt)
1223                 {
1224                         CodeConstructor c = new CodeConstructor ();
1225                         c.Attributes = MemberAttributes.Assembly;
1226                         c.Parameters.Add (Param (typeof (DataRowBuilder), "builder"));
1227                         c.BaseConstructorArgs.Add (ParamRef ("builder"));
1228                         c.Statements.Add (Let (FieldRef ("table"), Cast (
1229                                 opts.TableTypeName (dt.TableName, gen),
1230                                 PropRef ("Table"))));
1231                         return c;
1232                 }
1233
1234                 private CodeMemberField CreateRowTableField (DataTable dt)
1235                 {
1236                         CodeMemberField f = new CodeMemberField ();
1237                         f.Name = "table";
1238                         f.Type = TypeRef (opts.TableTypeName (dt.TableName, gen));
1239                         return f;
1240                 }
1241
1242                 private CodeMemberProperty CreateRowColumnProperty (DataTable dt, DataColumn col)
1243                 {
1244                         CodeMemberProperty p = new CodeMemberProperty ();
1245                         p.Name = opts.ColumnName (col.ColumnName, gen);
1246                         p.Type = TypeRef (col.DataType);
1247                         p.Attributes = MemberAttributes.Public;
1248
1249                         // This part should be better than MS code output.
1250                         // Code:
1251                         //  object ret = this [col];
1252                         //  if (ret == DBNull.Value)
1253                         //    throw new StrongTypingException ()
1254                         //  else
1255                         //    return (type) ret;
1256                         p.GetStatements.Add (VarDecl (typeof (object), "ret",
1257                                 IndexerRef (PropRef
1258                                         (PropRef ("table"),
1259                                         opts.TableColName (col.ColumnName, gen) + "Column"))));
1260                         p.GetStatements.Add (new CodeConditionStatement (
1261                                 Equals (
1262                                         Local ("ret"),
1263                                         PropRef (TypeRefExp (typeof (DBNull)), "Value")),
1264                                 new CodeStatement [] {
1265                                         Throw (New (typeof (StrongTypingException), Const ("Cannot get strong typed value since it is DB null."), Const (null))) },
1266                                 new CodeStatement [] {
1267                                         Return (Cast (col.DataType, Local ("ret"))) }));
1268
1269                         p.SetStatements.Add (Let (IndexerRef (PropRef (PropRef ("table"), opts.TableColName (col.ColumnName, gen) + "Column")), new CodePropertySetValueReferenceExpression ()));
1270
1271                         return p;
1272                 }
1273
1274                 private CodeMemberMethod CreateRowColumnIsNull (DataTable dt, DataColumn col)
1275                 {
1276                         CodeMemberMethod m = new CodeMemberMethod ();
1277                         m.Name = "Is" + opts.ColumnName (col.ColumnName, gen) + "Null";
1278                         m.Attributes = MemberAttributes.Public;
1279                         m.ReturnType = TypeRef (typeof (bool));
1280                         m.Statements.Add (Return (MethodInvoke (
1281                                 "IsNull",
1282                                 // table[foo].[bar]Column
1283                                 PropRef (
1284                                         PropRef ("table"),
1285                                         opts.TableColName (col.ColumnName, gen) + "Column"))));
1286                         return m;
1287                 }
1288
1289                 private CodeMemberMethod CreateRowColumnSetNull (DataTable dt, DataColumn col)
1290                 {
1291                         CodeMemberMethod m = new CodeMemberMethod ();
1292                         m.Name = "Set" + opts.ColumnName (col.ColumnName, gen) + "Null";
1293                         m.Attributes = MemberAttributes.Public;
1294                         m.Statements.Add (Let (IndexerRef (
1295                                 PropRef (
1296                                         PropRef ("table"),
1297                                         opts.TableColName (col.ColumnName, gen) + "Column")),
1298                                 PropRef (TypeRefExp (typeof (DBNull)), "Value")));
1299
1300                         return m;
1301                 }
1302
1303                 private CodeMemberProperty CreateRowParentRowProperty (DataTable dt, DataRelation rel)
1304                 {
1305                         CodeMemberProperty p = new CodeMemberProperty ();
1306                         p.Name = opts.TableMemberName (rel.ParentTable.TableName, gen) + "Row";
1307                         p.Attributes = MemberAttributes.Public;
1308                         p.Type = TypeRef (opts.RowName (rel.ParentTable.TableName, gen));
1309                         p.GetStatements.Add (Return (Cast (p.Type, MethodInvoke (
1310                                 "GetParentRow",
1311                                 IndexerRef (
1312                                         PropRef (
1313                                                 PropRef (
1314                                                         PropRef ("Table"),
1315                                                         "DataSet"),
1316                                                 "Relations"),
1317                                         Const (rel.RelationName))))));
1318                         p.SetStatements.Add (Eval (MethodInvoke (
1319                                 "SetParentRow",
1320                                 new CodePropertySetValueReferenceExpression (),
1321                                 IndexerRef (
1322                                         PropRef (
1323                                                 PropRef (
1324                                                         PropRef ("Table"),
1325                                                         "DataSet"),
1326                                                 "Relations"),
1327                                         Const (rel.RelationName)))));
1328
1329                         return p;
1330                 }
1331
1332                 private CodeMemberMethod CreateRowGetChildRows (DataTable dt, DataRelation rel)
1333                 {
1334                         CodeMemberMethod m = new CodeMemberMethod ();
1335                         m.Name = "Get" + opts.TableMemberName (rel.ChildTable.TableName, gen) + "Rows";
1336                         m.Attributes = MemberAttributes.Public;
1337                         m.ReturnType = new CodeTypeReference (opts.RowName (rel.ChildTable.TableName, gen), 1);
1338                         m.Statements.Add (Return (Cast (m.ReturnType, MethodInvoke (
1339                                 "GetChildRows",
1340                                 IndexerRef (
1341                                         PropRef (
1342                                                 PropRef (
1343                                                         PropRef ("Table"),
1344                                                         "DataSet"),
1345                                                 "Relations"),
1346                                         Const (rel.RelationName))))));
1347                         return m;
1348                 }
1349
1350 #endregion
1351
1352
1353 #region Event class
1354
1355                 // Code:
1356                 //  public class [foo]ChangeEventArgs : EventArgs
1357                 //  {
1358                 //    private [foo]Row row;
1359                 //    private DataRowAction action;
1360                 //    (.ctor())
1361                 //    (Row)
1362                 //    (Action)
1363                 //  }
1364                 private CodeTypeDeclaration GenerateEventType (DataTable dt)
1365                 {
1366                         CodeTypeDeclaration t = new CodeTypeDeclaration ();
1367                         t.Name = opts.EventArgsName (dt.TableName, gen);
1368                         t.BaseTypes.Add (TypeRef (typeof (EventArgs)));
1369                         t.Attributes = MemberAttributes.Public;
1370
1371                         t.Members.Add (
1372                                 new CodeMemberField (
1373                                         TypeRef (opts.RowName (dt.TableName, gen)),
1374                                         "row"));
1375                         t.Members.Add (
1376                                 new CodeMemberField (
1377                                         TypeRef (typeof (DataRowAction)), "action"));
1378                         t.Members.Add (CreateEventCtor (dt));
1379
1380                         t.Members.Add (CreateEventRow (dt));
1381
1382                         t.Members.Add (CreateEventAction (dt));
1383
1384                         return t;
1385                 }
1386
1387                 // Code:
1388                 //  public [foo]RowChangeEventArgs ([foo]Row r, DataRowAction a)
1389                 //  {
1390                 //    row = r;
1391                 //    action = a;
1392                 //  }
1393                 private CodeConstructor CreateEventCtor (DataTable dt)
1394                 {
1395                         CodeConstructor c = new CodeConstructor ();
1396                         c.Attributes = MemberAttributes.Public;
1397                         c.Parameters.Add (Param (TypeRef (opts.RowName (dt.TableName, gen)), "r"));
1398                         c.Parameters.Add (Param (TypeRef (typeof (DataRowAction)), "a"));
1399                         c.Statements.Add (Let (FieldRef ("row"), ParamRef ("r")));
1400                         c.Statements.Add (Let (FieldRef ("action"), ParamRef ("a")));
1401
1402                         return c;
1403                 }
1404
1405                 // Code:
1406                 //  public [foo]Row Row {
1407                 //   get { return row; }
1408                 // }
1409                 private CodeMemberProperty CreateEventRow (DataTable dt)
1410                 {
1411                         CodeMemberProperty p = new CodeMemberProperty ();
1412                         p.Name = "Row";
1413                         p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
1414                         p.Type = TypeRef (opts.RowName (dt.TableName, gen));
1415                         p.HasSet = false;
1416                         p.GetStatements.Add (Return (FieldRef ("row")));
1417                         return p;
1418                 }
1419
1420                 // Code:
1421                 //  public DataRowAction Action {
1422                 //   get { return action; }
1423                 // }
1424                 private CodeMemberProperty CreateEventAction (DataTable dt)
1425                 {
1426                         CodeMemberProperty p = new CodeMemberProperty ();
1427                         p.Name = "Action";
1428                         p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
1429                         p.Type = TypeRef (typeof (DataRowAction));
1430                         p.HasSet = false;
1431                         p.GetStatements.Add (Return (FieldRef ("action")));
1432                         return p;
1433                 }
1434
1435 #endregion
1436
1437         }
1438 }
1439
1440
1441 /* =========================================================
1442
1443
1444 MonoDataSetGenerator API notes
1445
1446
1447 ** generator API:
1448         CreateDataSetClasses (
1449                 DataSet ds,
1450                 CodeNamespace cns,
1451                 ICodeGenerator gen,
1452                 GeneratorOptions options)
1453
1454 ** classes:
1455
1456 *** Code naming method delegate
1457
1458         public delegate string CodeNamingMethod (string sourceName);
1459
1460         It is used in CodeGeneratorOptions (describled immediately below).
1461
1462
1463
1464 *** Generator Options
1465
1466         public bool MakeClassesInsideDataSet
1467                 indicates whether classes and delegates other than DataSet
1468                 itself are "contained" in the DataSet class or not.
1469
1470         public CodeNamingMethod CreateDataSetName;
1471         public CodeNamingMethod CreateTableTypeName;
1472         public CodeNamingMethod CreateTableMemberName;
1473         public CodeNamingMethod CreateColumnName;
1474         public CodeNamingMethod CreateRowName;
1475         public CodeNamingMethod CreateRelationName;
1476         public CodeNamingMethod CreateTableDelegateName;
1477         public CodeNamingMethod CreateEventArgsName;
1478                 Custom methods each of that returns type or member name.
1479
1480                 By default, they are set as to useTypedDataSetGenerator.
1481                 CreateIdName() with modifications listed as below:
1482
1483                 DataSetName: as is
1484                 TableTypeName: "DataTable" suffix
1485                 TableMemberName: as is
1486                 ColumnName: as is
1487                 RowName: "Row" suffix
1488                 RelationName: (TBD; maybe had better have another delegate type)
1489                 DelegateName: "RowChangedEventHandler" suffix
1490                 EventArgsName: "RowChangedEventArgs" suffix
1491
1492 ** Auto Generated classes
1493
1494 1. Custom DataSet class
1495
1496         class name = dataset name, encoded by options.CreateDataSetName().
1497
1498 *** .ctor
1499
1500         public default .ctor()
1501                 "initialize" class.
1502                 set custom delegate on Tables.CollectionChanged
1503                 set custom delegate on Relations.CollectionChanged
1504
1505         runtime serialization .ctor()
1506                 TBD
1507
1508 *** public members
1509
1510         data tables: [foo]DataTable foo { return this.table[foo]; }
1511
1512         Clone()
1513                 init variables on new dataset.
1514
1515 *** protected members
1516
1517         ShouldSerializeTables()
1518                 returns false, while default DataSet returns true.
1519         ShouldSerializeRelations()
1520                 returns false, while default DataSet returns true.
1521
1522         ReadXmlSerializable() ... similar to runtime serialization
1523                 TBD
1524
1525         GetSchemaSerializable()
1526                 Write its schema to temporary MemoryStream
1527                 Read XML schema from the stream
1528
1529 *** internal members
1530
1531         "init variables"
1532                 set member fields (tables, relations)
1533                 call members' "init variables"
1534
1535         "init class"
1536                 set DataSetName, Prefix, Namespace, Locale, CaseSensitive, EnforceConstraints
1537                 for each table
1538                         allocate table[foo]
1539                         Tables.Add()
1540                         create FKC: new FKC([rel], new DataColumn [] {table[foo].[keyColumnName]Column}, new DataColumn [] {table[child].[childColName]Column}
1541                 fill Rule properties.
1542                 allocate relation[rel] and fill Nested, then Relations.Add()
1543
1544 *** private members
1545
1546         data tables: [foo]DataTable table[foo];
1547
1548         data relations: DataRelation relation[rel];
1549
1550         ShouldSerialize[foo]
1551
1552
1553
1554 2. Custom DataTable classes for each DataTable
1555
1556         This class is created under the dataset.
1557
1558 *** internal members
1559
1560         .ctor() : base("[foo]")
1561                 initialize class
1562
1563         .ctor(DataTable)
1564                 wtf?
1565
1566         DataColumn [bar]Column { return column[bar]; }
1567
1568         "init variables"()
1569                 fill each column fields
1570
1571 *** public members
1572
1573         int Count { rowcount }
1574
1575         this [int index] { row [i]; }
1576
1577         event [foo]RowChangedEventHandler [foo]RowChanged
1578         event [foo]RowChangedEventHandler [foo]RowChanging
1579         event [foo]RowChangedEventHandler [foo]RowDeleted
1580         event [foo]RowChangedEventHandler [foo]RowDeleting
1581
1582         void Add[foo]Row ([foo]Row row) { Rows.Add (row); }
1583
1584         [foo]Row Add[foo]Row ([columnType] [columnName])
1585                 create new [foo]row.
1586                 set members
1587                 Rows.Add ()
1588                 // where
1589                 //      non-relation-children are just created as column type
1590                 //      relation-children are typeof fooRow[]
1591
1592         GetEnumerator() { Rows.GetEnumerator (); }
1593
1594         override DataTable Clone()
1595                 "init variables"
1596
1597         [foo]Row New[foo]Row()
1598
1599         void Remove[foo]Row([foo]Row)
1600
1601         //for each ChildRelations
1602         [bar]Row [] Get[foo_bar]Rows ()
1603
1604 *** protected members
1605
1606         override DataTable CreateInstance() { return new }
1607
1608         override DataRow NewRowFromBuilder(DataRowBuilder)
1609
1610         override Type GetRowType()
1611
1612         override void OnRowChanged(DataRowChangedEventArgs)
1613                 base.()
1614                 check this event [foo]RowChanged.
1615
1616         override void OnRowChanging(DataRowChangedEventArgs)
1617         override void OnRowDeleted(DataRowChangedEventArgs)
1618         override void OnRowDeleting(DataRowChangedEventArgs)
1619         ... as well
1620
1621 *** private members
1622
1623         "initialize class"
1624                 for each columns {
1625                         column[bar] = new DataColumn (...);
1626                         Columns.Add()
1627                 }
1628
1629         DataColumn [bar]Column
1630
1631 3. Custom DataRow classses
1632
1633 *** public members
1634
1635         for simple members:
1636
1637                 [bar_type] [bar] {
1638                         get { try { } catch { throw StrongTypingException(); }
1639                         set { this [[foo]Table.[bar]Column] = value; }
1640
1641                 bool Is[bar]Null ()
1642                         IsNull ([foo]Table.[bar]Column);
1643
1644                 void Set[bar]Null ()
1645
1646         if the table is parent of some relations
1647
1648                 public [child]Row [] Get[child]Rows()
1649
1650 *** internal members
1651
1652         .ctor(DataRowBuilder) : base.()
1653                 table[foo] = Table;
1654
1655 *** private members
1656
1657         [foo]DataTable table[foo]
1658
1659
1660 4. Custom DataRowChangeEvent classes
1661
1662 *** private members
1663
1664         [foo]Row eventRow
1665         DataRowAction eventAction
1666
1667 *** public members
1668
1669         .ctor([foo]Row row, DataRowAction action)
1670
1671         [foo]Row Row
1672
1673         DataRowAction Action
1674
1675
1676
1677 5. public Table RowChangedEventHandler delegates
1678
1679         [foo]RowChangedEventHandler(object, [foo]RowChangedEvent e)
1680
1681
1682 ======================================================== */