//------------------------------------------------------------------------------
// <copyright file="DataRowExtenstions.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">spather</owner>
//------------------------------------------------------------------------------
using System;
using System.Data.DataSetExtensions;

namespace System.Data {
    
    /// <summary>
    /// This static class defines the DataRow extension methods.
    /// </summary>
    public static class DataRowExtensions {
    
        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="columnName">
        ///   The input column name specificy which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, string columnName) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[columnName]);
        }
        
        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="column">
        ///   The input DataColumn specificy which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, DataColumn column) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[column]);
        }

        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="columnIndex">
        ///   The input ordinal specificy which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, int columnIndex) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[columnIndex]);
        }

        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="columnIndex">
        ///   The input ordinal specificy which row value to retrieve.
        /// </param>
        /// <param name="version">
        ///   The DataRow version for which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, int columnIndex, DataRowVersion version) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[columnIndex, version]);
        }

        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="columnName">
        ///   The input column name specificy which row value to retrieve.
        /// </param>
        /// <param name="version">
        ///   The DataRow version for which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, string columnName, DataRowVersion version) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[columnName, version]);
        }

        /// <summary>
        ///  This method provides access to the values in each of the columns in a given row. 
        ///  This method makes casts unnecessary when accessing columns. 
        ///  Additionally, Field supports nullable types and maps automatically between DBNull and 
        ///  Nullable when the generic type is nullable. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow
        /// </param>
        /// <param name="column">
        ///   The input DataColumn specificy which row value to retrieve.
        /// </param>
        /// <param name="version">
        ///   The DataRow version for which row value to retrieve.
        /// </param>
        /// <returns>
        ///   The DataRow value for the column specified.
        /// </returns> 
        public static T Field<T>(this DataRow row, DataColumn column, DataRowVersion version) {
            DataSetUtil.CheckArgumentNull(row, "row");
            return UnboxT<T>.Unbox(row[column, version]);
        }

        /// <summary>
        ///  This method sets a new value for the specified column for the DataRow it’s called on. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow.
        /// </param>
        /// <param name="columnIndex">
        ///   The input ordinal specifying which row value to set.
        /// </param>
        /// <param name="value">
        ///   The new row value for the specified column.
        /// </param>
        public static void SetField<T>(this DataRow row, int columnIndex, T value) {
            DataSetUtil.CheckArgumentNull(row, "row");
            row[columnIndex] = (object)value ?? DBNull.Value;
        }
        
        /// <summary>
        ///  This method sets a new value for the specified column for the DataRow it’s called on. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow.
        /// </param>
        /// <param name="columnName">
        ///   The input column name specificy which row value to retrieve.
        /// </param>
        /// <param name="value">
        ///   The new row value for the specified column.
        /// </param>
        public static void SetField<T>(this DataRow row, string columnName, T value) {
            DataSetUtil.CheckArgumentNull(row, "row");
            row[columnName] = (object)value ?? DBNull.Value;
        }

        /// <summary>
        ///  This method sets a new value for the specified column for the DataRow it’s called on. 
        /// </summary>
        /// <param name="row">
        ///   The input DataRow.
        /// </param>
        /// <param name="column">
        ///   The input DataColumn specificy which row value to retrieve.
        /// </param>
        /// <param name="value">
        ///   The new row value for the specified column.
        /// </param>
        public static void SetField<T>(this DataRow row, DataColumn column, T value) {
            DataSetUtil.CheckArgumentNull(row, "row");
            row[column] = (object)value ?? DBNull.Value;
        }

        private static class UnboxT<T>
        {
            internal static readonly Converter<object, T> Unbox = Create(typeof(T));

            private static Converter<object, T> Create(Type type)
            {
                if (type.IsValueType)
                {
                    if (type.IsGenericType && !type.IsGenericTypeDefinition && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
                    {
                        return (Converter<object, T>)Delegate.CreateDelegate(
                            typeof(Converter<object, T>),
                                typeof(UnboxT<T>)
                                    .GetMethod("NullableField", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)
                                    .MakeGenericMethod(type.GetGenericArguments()[0]));
                    }
                    return ValueField;
                }
                return ReferenceField;
            }

            private static T ReferenceField(object value)
            {
                return ((DBNull.Value == value) ? default(T) : (T)value);
            }

            private static T ValueField(object value)
            {
                if (DBNull.Value == value)
                {
                    throw DataSetUtil.InvalidCast(Strings.DataSetLinq_NonNullableCast(typeof(T).ToString()));
                }
                return (T)value;
            }

            private static Nullable<TElem> NullableField<TElem>(object value) where TElem : struct
            {
                if (DBNull.Value == value)
                {
                    return default(Nullable<TElem>);
                }
                return new Nullable<TElem>((TElem)value);
            }
        }
    }
}