// ------------------------------------------------------------------------------
//  [autogenerated]
//      This code was generated by a tool.
//      Runtime Version: 1.1.4322.573
// 
//      Changes to this file may cause incorrect behavior and will be lost if 
//      the code is regenerated.
//  </autogenerated>
// ------------------------------------------------------------------------------

// 
//This source code was auto-generated by MonoXSD
//
/// REFERENCE: System.Data

namespace Schemas {
    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Data;
    using System.Runtime.Serialization;
    using System.Xml;

    public class NewDataSet : System.Data.DataSet {

        public delegate rootRowChangedEventHandler (o : object, e : rootRowChangedEventArgs) : void;

        mutable __tableroot : rootDataTable;

        public this () {
            this.InitializeClass();
            mutable handler = System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += handler;
            this.Relations.CollectionChanged += handler;
        }

        protected this (_info : System.Runtime.Serialization.SerializationInfo, _ctx : System.Runtime.Serialization.StreamingContext) {
            // TODO: implement
            throw System.NotImplementedException();
        }

        public virtual root : rootDataTable {
            get {
                this.__tableroot;
            }
        }

        public override Clone () : System.Data.DataSet {
            mutable set = (base.Clone() :> NewDataSet);
            set.InitializeFields();
            set;
        }

        internal InitializeClass () : void {
            this.DataSetName = "NewDataSet";
            this.Prefix = "";
            this.Namespace = "";
            this.Locale = System.Globalization.CultureInfo("pl-PL");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.__tableroot = rootDataTable();
            this.Tables.Add(this.__tableroot);
        }

        internal InitializeFields () : void {
            this.__tableroot.InitializeFields();
        }

        SchemaChanged (_sender : object, e : System.ComponentModel.CollectionChangeEventArgs) : void {
            when ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitializeFields();
            }
        }

        public class rootDataTable : System.Data.DataTable, System.Collections.IEnumerable {

            mutable __columnfoo : System.Data.DataColumn;

            mutable __columnbar : System.Data.DataColumn;

            mutable __columnbaz : System.Data.DataColumn;

            internal this () {
                base ("root");
                this.InitializeClass();
            }

            internal this (table : System.Data.DataTable) {
                base (table.TableName);
                // TODO: implement
                throw System.NotImplementedException();
            }

            public virtual Count : int {
                get {
                    this.Rows.Count;
                }
            }

            public virtual Item [i : int] : rootRow {
                get {
                    (this.Rows[i] :> rootRow);
                }
            }

            internal fooColumn : System.Data.DataColumn {
                get {
                    this.__columnfoo;
                }
            }

            internal barColumn : System.Data.DataColumn {
                get {
                    this.__columnbar;
                }
            }

            internal bazColumn : System.Data.DataColumn {
                get {
                    this.__columnbaz;
                }
            }

            public event rootRowChanging : rootRowChangedEventHandler;

            public event rootRowChanged : rootRowChangedEventHandler;

            public event rootRowDeleting : rootRowChangedEventHandler;

            public event rootRowDeleted : rootRowChangedEventHandler;

            InitializeClass () : void {
                this.Columns.Add(System.Data.DataColumn("foo"));
                this.Columns.Add(System.Data.DataColumn("bar"));
                this.Columns.Add(System.Data.DataColumn("baz"));
            }

            internal InitializeFields () : void {
                this.__columnfoo = this.Columns["foo"];
                this.__columnbar = this.Columns["bar"];
                this.__columnbaz = this.Columns["baz"];
            }

            public virtual GetEnumerator () : System.Collections.IEnumerator {
                this.Rows.GetEnumerator();
            }

            public override Clone () : System.Data.DataTable {
                mutable t = (base.Clone() :> rootDataTable);
                t.InitializeFields();
                t;
            }

            protected override CreateInstance () : System.Data.DataTable {
                rootDataTable();
            }

            public virtual AddrootRow (row : rootRow) : void {
                this.Rows.Add(row);
            }

            public virtual AddrootRow (foo : string, bar : string, baz : string) : rootRow {
                mutable row = this.NewrootRow();
                row["foo"] = foo;
                row["bar"] = bar;
                row["baz"] = baz;
                this.Rows.Add(row);
                row;
            }

            public virtual NewrootRow () : rootRow {
                (this.NewRow() :> rootRow);
            }

            protected override NewRowFromBuilder (builder : System.Data.DataRowBuilder) : System.Data.DataRow {
                rootRow(builder);
            }

            public virtual RemoverootRow (row : rootRow) : void {
                this.Rows.Remove(row);
            }

            protected override GetRowType () : System.Type {
                typeof(rootRow);
            }

            protected override OnRowChanging (e : System.Data.DataRowChangeEventArgs) : void {
                base.OnRowChanging(e);
                when ((this.rootRowChanging != null)) {
                    this.rootRowChanging(this, rootRowChangedEventArgs((e.Row :> rootRow), e.Action));
                }
            }

            protected override OnRowChanged (e : System.Data.DataRowChangeEventArgs) : void {
                base.OnRowChanged(e);
                when ((this.rootRowChanged != null)) {
                    this.rootRowChanged(this, rootRowChangedEventArgs((e.Row :> rootRow), e.Action));
                }
            }

            protected override OnRowDeleting (e : System.Data.DataRowChangeEventArgs) : void {
                base.OnRowDeleting(e);
                when ((this.rootRowDeleting != null)) {
                    this.rootRowDeleting(this, rootRowChangedEventArgs((e.Row :> rootRow), e.Action));
                }
            }

            protected override OnRowDeleted (e : System.Data.DataRowChangeEventArgs) : void {
                base.OnRowDeleted(e);
                when ((this.rootRowDeleted != null)) {
                    this.rootRowDeleted(this, rootRowChangedEventArgs((e.Row :> rootRow), e.Action));
                }
            }
        }

        public class rootRow : System.Data.DataRow {

            mutable table : rootDataTable;

            internal this (builder : System.Data.DataRowBuilder) {
                base (builder);
                this.table = (this.Table :> rootDataTable);
            }

            public virtual foo : string {
                get {
                    mutable ret = this[this.table.fooColumn];
                    if ((ret == System.DBNull.Value)) {
                        throw System.Data.StrongTypingException("Cannot get strong typed value since it is DB null.", null);
                    }
                    else {
                        (ret :> string);
                    }
                }
                set {
                    this[this.table.fooColumn] = value;
                }
            }

            public virtual bar : string {
                get {
                    mutable ret = this[this.table.barColumn];
                    if ((ret == System.DBNull.Value)) {
                        throw System.Data.StrongTypingException("Cannot get strong typed value since it is DB null.", null);
                    }
                    else {
                        (ret :> string);
                    }
                }
                set {
                    this[this.table.barColumn] = value;
                }
            }

            public virtual baz : string {
                get {
                    mutable ret = this[this.table.bazColumn];
                    if ((ret == System.DBNull.Value)) {
                        throw System.Data.StrongTypingException("Cannot get strong typed value since it is DB null.", null);
                    }
                    else {
                        (ret :> string);
                    }
                }
                set {
                    this[this.table.bazColumn] = value;
                }
            }

            public virtual IsfooNull () : bool {
                this.IsNull(this.table.fooColumn);
            }

            public virtual SetfooNull () : void {
                this[this.table.fooColumn] = System.DBNull.Value;
            }

            public virtual IsbarNull () : bool {
                this.IsNull(this.table.barColumn);
            }

            public virtual SetbarNull () : void {
                this[this.table.barColumn] = System.DBNull.Value;
            }

            public virtual IsbazNull () : bool {
                this.IsNull(this.table.bazColumn);
            }

            public virtual SetbazNull () : void {
                this[this.table.bazColumn] = System.DBNull.Value;
            }
        }

        public class rootRowChangedEventArgs : System.EventArgs {

            mutable row : rootRow;

            mutable action : System.Data.DataRowAction;

            public this (r : rootRow, a : System.Data.DataRowAction) {
                this.row = r;
                this.action = a;
            }

            public Row : rootRow {
                get {
                    this.row;
                }
            }

            public Action : System.Data.DataRowAction {
                get {
                    this.action;
                }
            }
        }
        }

        }