Click here to Skip to main content
15,888,521 members
Articles / Programming Languages / C#

Managed C++ wrapper for ZLib

Rate me:
Please Sign up or sign in to vote.
4.56/5 (14 votes)
3 Mar 2005CPOL9 min read 155.4K   5.7K   46  
.NET wrapper for ZLib, written in MC++
//------------------------------------------------------------------------------
// <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>
//------------------------------------------------------------------------------

namespace ZTest {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;
    
    
    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class FibonacciDataSet : DataSet {
        
        private FibonacciDataTable tableFibonacci;
        
        public FibonacciDataSet() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected FibonacciDataSet(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["Fibonacci"] != null)) {
                    this.Tables.Add(new FibonacciDataTable(ds.Tables["Fibonacci"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public FibonacciDataTable Fibonacci {
            get {
                return this.tableFibonacci;
            }
        }
        
        public override DataSet Clone() {
            FibonacciDataSet cln = ((FibonacciDataSet)(base.Clone()));
            cln.InitVars();
            return cln;
        }
        
        protected override bool ShouldSerializeTables() {
            return false;
        }
        
        protected override bool ShouldSerializeRelations() {
            return false;
        }
        
        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["Fibonacci"] != null)) {
                this.Tables.Add(new FibonacciDataTable(ds.Tables["Fibonacci"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }
        
        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }
        
        internal void InitVars() {
            this.tableFibonacci = ((FibonacciDataTable)(this.Tables["Fibonacci"]));
            if ((this.tableFibonacci != null)) {
                this.tableFibonacci.InitVars();
            }
        }
        
        private void InitClass() {
            this.DataSetName = "FibonacciDataSet";
            this.Prefix = "";
            this.Namespace = "http://tempuri.org/Fibonacci.xsd";
            this.Locale = new System.Globalization.CultureInfo("en-US");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.tableFibonacci = new FibonacciDataTable();
            this.Tables.Add(this.tableFibonacci);
        }
        
        private bool ShouldSerializeFibonacci() {
            return false;
        }
        
        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }
        
        public delegate void FibonacciRowChangeEventHandler(object sender, FibonacciRowChangeEvent e);
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class FibonacciDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnx;
            
            private DataColumn columnFn;
            
            private DataColumn column_Fn_Fn_1;
            
            internal FibonacciDataTable() : 
                    base("Fibonacci") {
                this.InitClass();
            }
            
            internal FibonacciDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn xColumn {
                get {
                    return this.columnx;
                }
            }
            
            internal DataColumn FnColumn {
                get {
                    return this.columnFn;
                }
            }
            
            internal DataColumn _Fn_Fn_1Column {
                get {
                    return this.column_Fn_Fn_1;
                }
            }
            
            public FibonacciRow this[int index] {
                get {
                    return ((FibonacciRow)(this.Rows[index]));
                }
            }
            
            public event FibonacciRowChangeEventHandler FibonacciRowChanged;
            
            public event FibonacciRowChangeEventHandler FibonacciRowChanging;
            
            public event FibonacciRowChangeEventHandler FibonacciRowDeleted;
            
            public event FibonacciRowChangeEventHandler FibonacciRowDeleting;
            
            public void AddFibonacciRow(FibonacciRow row) {
                this.Rows.Add(row);
            }
            
            public FibonacciRow AddFibonacciRow(int x, System.Double Fn, System.Double _Fn_Fn_1) {
                FibonacciRow rowFibonacciRow = ((FibonacciRow)(this.NewRow()));
                rowFibonacciRow.ItemArray = new object[] {
                        x,
                        Fn,
                        _Fn_Fn_1};
                this.Rows.Add(rowFibonacciRow);
                return rowFibonacciRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                FibonacciDataTable cln = ((FibonacciDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new FibonacciDataTable();
            }
            
            internal void InitVars() {
                this.columnx = this.Columns["x"];
                this.columnFn = this.Columns["Fn"];
                this.column_Fn_Fn_1 = this.Columns["Fn/Fn-1"];
            }
            
            private void InitClass() {
                this.columnx = new DataColumn("x", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnx);
                this.columnFn = new DataColumn("Fn", typeof(System.Double), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnFn);
                this.column_Fn_Fn_1 = new DataColumn("Fn/Fn-1", typeof(System.Double), null, System.Data.MappingType.Element);
                this.Columns.Add(this.column_Fn_Fn_1);
            }
            
            public FibonacciRow NewFibonacciRow() {
                return ((FibonacciRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new FibonacciRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(FibonacciRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.FibonacciRowChanged != null)) {
                    this.FibonacciRowChanged(this, new FibonacciRowChangeEvent(((FibonacciRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.FibonacciRowChanging != null)) {
                    this.FibonacciRowChanging(this, new FibonacciRowChangeEvent(((FibonacciRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.FibonacciRowDeleted != null)) {
                    this.FibonacciRowDeleted(this, new FibonacciRowChangeEvent(((FibonacciRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.FibonacciRowDeleting != null)) {
                    this.FibonacciRowDeleting(this, new FibonacciRowChangeEvent(((FibonacciRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveFibonacciRow(FibonacciRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class FibonacciRow : DataRow {
            
            private FibonacciDataTable tableFibonacci;
            
            internal FibonacciRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableFibonacci = ((FibonacciDataTable)(this.Table));
            }
            
            public int x {
                get {
                    try {
                        return ((int)(this[this.tableFibonacci.xColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableFibonacci.xColumn] = value;
                }
            }
            
            public System.Double Fn {
                get {
                    try {
                        return ((System.Double)(this[this.tableFibonacci.FnColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableFibonacci.FnColumn] = value;
                }
            }
            
            public System.Double _Fn_Fn_1 {
                get {
                    try {
                        return ((System.Double)(this[this.tableFibonacci._Fn_Fn_1Column]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableFibonacci._Fn_Fn_1Column] = value;
                }
            }
            
            public bool IsxNull() {
                return this.IsNull(this.tableFibonacci.xColumn);
            }
            
            public void SetxNull() {
                this[this.tableFibonacci.xColumn] = System.Convert.DBNull;
            }
            
            public bool IsFnNull() {
                return this.IsNull(this.tableFibonacci.FnColumn);
            }
            
            public void SetFnNull() {
                this[this.tableFibonacci.FnColumn] = System.Convert.DBNull;
            }
            
            public bool Is_Fn_Fn_1Null() {
                return this.IsNull(this.tableFibonacci._Fn_Fn_1Column);
            }
            
            public void Set_Fn_Fn_1Null() {
                this[this.tableFibonacci._Fn_Fn_1Column] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class FibonacciRowChangeEvent : EventArgs {
            
            private FibonacciRow eventRow;
            
            private DataRowAction eventAction;
            
            public FibonacciRowChangeEvent(FibonacciRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public FibonacciRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Software Developer (Senior)
Italy Italy
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.

Comments and Discussions