mono/mcs/class/referencesource/System.Data/System/Data/Common/DataTableMapping.cs

//------------------------------------------------------------------------------
// <copyright file="DataTableMapping.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------

namespace System.Data.Common {

    using System;
    using System.ComponentModel;
    using System.ComponentModel.Design.Serialization;
    using System.Data;
    using System.Diagnostics;
    using System.Globalization;
    using System.Reflection;

    [
    System.ComponentModel.TypeConverterAttribute(typeof(System.Data.Common.DataTableMapping.DataTableMappingConverter))
    ]
    public sealed class DataTableMapping : MarshalByRefObject, ITableMapping, ICloneable {
        private DataTableMappingCollection parent;
        private DataColumnMappingCollection _columnMappings;
        private string _dataSetTableName;
        private string _sourceTableName;

        public DataTableMapping() {
        }

        public DataTableMapping(string sourceTable, string dataSetTable) {
            SourceTable = sourceTable;
            DataSetTable = dataSetTable;
        }

        public DataTableMapping(string sourceTable, string dataSetTable, DataColumnMapping[] columnMappings) {
            SourceTable = sourceTable;
            DataSetTable = dataSetTable;
            if ((null != columnMappings) && (0 < columnMappings.Length)) {
                ColumnMappings.AddRange(columnMappings);
            }
        }

        // explict ITableMapping implementation
        IColumnMappingCollection ITableMapping.ColumnMappings {
            get { return ColumnMappings; }
        }

        [
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        ResCategoryAttribute(Res.DataCategory_Mapping),
        ResDescriptionAttribute(Res.DataTableMapping_ColumnMappings),
        ]
        public DataColumnMappingCollection ColumnMappings {
            get {
                DataColumnMappingCollection columnMappings = _columnMappings;
                if (null == columnMappings) {
                    columnMappings = new DataColumnMappingCollection();
                    _columnMappings = columnMappings;
                }
                return columnMappings;
            }
        }

        [
        DefaultValue(""),
        ResCategoryAttribute(Res.DataCategory_Mapping),
        ResDescriptionAttribute(Res.DataTableMapping_DataSetTable),
        ]
        public string DataSetTable {
            get {
                string dataSetTableName = _dataSetTableName;
                return ((null != dataSetTableName) ? dataSetTableName : ADP.StrEmpty);
            }
            set {
                _dataSetTableName = value;
            }
        }
        
        internal DataTableMappingCollection Parent {
            get {
                return parent;
            }
            set {
                parent = value;
            }
        }

        [
        DefaultValue(""),
        ResCategoryAttribute(Res.DataCategory_Mapping),
        ResDescriptionAttribute(Res.DataTableMapping_SourceTable),
        ]
        public string SourceTable {
            get {
                string sourceTableName = _sourceTableName;
                return ((null != sourceTableName) ? sourceTableName : ADP.StrEmpty);
            }
            set {
                if ((null != Parent) && (0 != ADP.SrcCompare(_sourceTableName, value))) {
                    Parent.ValidateSourceTable(-1, value);
                }
                _sourceTableName = value;
            }
        }

        object ICloneable.Clone() {
            DataTableMapping clone = new DataTableMapping(); // MDAC 81448
            clone._dataSetTableName = _dataSetTableName;
            clone._sourceTableName = _sourceTableName;

            if ((null != _columnMappings) && (0 < ColumnMappings.Count)) {
                DataColumnMappingCollection parameters = clone.ColumnMappings;
                foreach(ICloneable parameter in ColumnMappings) {
                    parameters.Add(parameter.Clone());
                }
            }
            return clone;
        }

        [ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
        public DataColumn GetDataColumn(string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction) {
            return DataColumnMappingCollection.GetDataColumn(_columnMappings, sourceColumn, dataType, dataTable, mappingAction, schemaAction);
        }
        
        [ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
        public DataColumnMapping GetColumnMappingBySchemaAction(string sourceColumn, MissingMappingAction mappingAction) {
            return DataColumnMappingCollection.GetColumnMappingBySchemaAction(_columnMappings, sourceColumn, mappingAction);
        }

        [ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
        public DataTable GetDataTableBySchemaAction(DataSet dataSet, MissingSchemaAction schemaAction) {
            if (null == dataSet) {
                throw ADP.ArgumentNull("dataSet");
            }
            string dataSetTable = DataSetTable;

            if (ADP.IsEmpty(dataSetTable)) {
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceWarning) {
                    Debug.WriteLine("explicit filtering of SourceTable \"" + SourceTable + "\"");
                }
#endif
                return null;
            }
            DataTableCollection tables = dataSet.Tables;
            int index = tables.IndexOf(dataSetTable);
            if ((0 <= index) && (index < tables.Count)) {
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceInfo) {
                    Debug.WriteLine("schema match on DataTable \"" + dataSetTable);
                }
#endif
                return tables[index];
            }
            switch (schemaAction) {
                case MissingSchemaAction.Add:
                case MissingSchemaAction.AddWithKey:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo) {
                        Debug.WriteLine("schema add of DataTable \"" + dataSetTable + "\"");
                    }
#endif
                    return new DataTable(dataSetTable);

                case MissingSchemaAction.Ignore:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceWarning) {
                        Debug.WriteLine("schema filter of DataTable \"" + dataSetTable + "\"");
                    }
#endif
                    return null;

                case MissingSchemaAction.Error:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceError) {
                        Debug.WriteLine("schema error on DataTable \"" + dataSetTable + "\"");
                    }
#endif
                    throw ADP.MissingTableSchema(dataSetTable, SourceTable);
            }
            throw ADP.InvalidMissingSchemaAction(schemaAction);
        }

        public override String ToString() {
            return SourceTable;
        }

        sealed internal class DataTableMappingConverter : System.ComponentModel.ExpandableObjectConverter {

            // converter classes should have public ctor
            public DataTableMappingConverter() {
            }

            override public bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
                if (typeof(InstanceDescriptor) == destinationType) {
                    return true;
                }
                return base.CanConvertTo(context, destinationType);
            }

            override public object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
                if (null == destinationType) {
                    throw ADP.ArgumentNull("destinationType");
                }

                if ((typeof(InstanceDescriptor) == destinationType) && (value is DataTableMapping)) {
                    DataTableMapping mapping = (DataTableMapping)value;

                    DataColumnMapping[] columnMappings = new DataColumnMapping[mapping.ColumnMappings.Count];
                    mapping.ColumnMappings.CopyTo(columnMappings, 0);
                    object[] values = new object[] { mapping.SourceTable, mapping.DataSetTable, columnMappings};
                    Type[] types = new Type[] { typeof(string), typeof(string), typeof(DataColumnMapping[]) };

                    ConstructorInfo ctor = typeof(DataTableMapping).GetConstructor(types);
                    return new InstanceDescriptor(ctor, values);
                }            
                return base.ConvertTo(context, culture, value, destinationType);
            }
        }
    }
}