Converter_3T.cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2013-2016
// </copyright>
// <summary>   A tested, generic, portable, runtime-extensible type converter library   </summary
// <language>  C# > 6.0                                                                 </language>
// <version>   3.1.0.2                                                                  </version>
// <author>    Lorenz Lo Sauer; people credited in the sources                          </author>
// <project>   https://github.com/lsauer/dotnet-portable-type-cast                      </project>
namespace Core.TypeCast
{
    using System;
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Runtime.Serialization;

    using Core.TypeCast.Base;

    [DataContract]
    public class Converter<TIn, TOut, TArg> : Converter, IConverter<TIn, TOut>
    {
        public Converter(Func<TIn, TOut> converter)
            : base(typeof(TIn), typeof(TOut), typeof(TArg))
        {
            // Prevent null types in the base
            if(converter == null)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentNull);
            }

            this.ConverterFunc = converter;
        }

        public Converter(Func<TIn, TOut, TOut> converterDefault)
            : base(typeof(TIn), typeof(TOut), typeof(TArg))
        {
            if(converterDefault == null)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentNull);
            }

            this.ConverterDefaultFunc = converterDefault;
        }

        public Converter(Func<TIn, TArg, TOut> converterAny, Type argument = null)
            : base(typeof(TIn), typeof(TOut), argument ?? typeof(TArg))
        {
            if(converterAny == null)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentNull);
            }

            this.DefaultValueAnyType = true;
            this.ConverterAnyFunc = converterAny;
        }

        public Converter(MethodInfo converterInfo, Type argument = null)
            : base(typeof(TIn), typeof(TOut), argument ?? typeof(TArg))
        {
            var parameterCount = converterInfo.GetParameters().Length;

            if(converterInfo == null || parameterCount == 0)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentNull);
            }

            if(parameterCount == 1)
            {
                this.FunctionInfo = converterInfo;
                this.ConverterFunc = (Func<TIn, TOut>)converterInfo.CreateDelegate(typeof(Func<TIn, TOut>), null);
                ;

            }
            else if(parameterCount == 2)
            {
                this.FunctionDefaultInfo = converterInfo;
                this.DefaultValueAnyType = true;
                this.ConverterAnyFunc = (Func<TIn, TArg, TOut>)converterInfo.CreateDelegate(typeof(Func<TIn, TArg, TOut>), null);
            }
            else
            {
                throw new ConverterException(ConverterCause.ConverterArgumentDelegateTooManyParameters);
            }
        }

        [DataMember]
        public Func<TIn, TArg, TOut> ConverterAnyFunc
        {
            get
            {
                return (Func<TIn, TArg, TOut>)this.FunctionDefault;
            }

            set
            {
                this.FunctionDefault = (object)value;
            }
        }

        [DataMember]
        public Func<TIn, TOut, TOut> ConverterDefaultFunc
        {
            get
            {
                return (Func<TIn, TOut, TOut>)this.FunctionDefault;
            }

            set
            {
                this.FunctionDefault = (object)value;
            }
        }

        [DataMember]
        public Func<TIn, TOut> ConverterFunc
        {
            get
            {
                return (Func<TIn, TOut>)this.Function;
            }

            set
            {
                this.Function = (object)value;
            }
        }

        public override object Convert(object value, object defaultValue = null)
        {
            this.CheckConvertTypes(value, defaultValue);

            try
            {
                if(this.HasDefaultFunctionOnly == true || (defaultValue != null && ObjectExtension.IsDefaultValue<TOut>(defaultValue) == false))
                {
                    return this.ConvertDefault(ref value, ref defaultValue);
                }

                if(this.ConverterFunc != null)
                {
                    if(this.Base != null && this.FunctionAttribute?.IsStatic == false && this.FunctionInfo?.IsStatic == false)
                    {
                        return this.FunctionInfo.Invoke(this.Base, new[] { value });
                    }

                    return this.ConverterFunc.Invoke((TIn)value);
                }
            }
            catch(InvalidCastException)
            {
                throw new ConverterException(ConverterCause.InvalidCast);
            }
            catch(Exception)
            {
                throw;
            }

            throw new ConverterException(ConverterCause.ConverterFunctionNull);
        }

        private object ConvertDefault(ref object value, ref object defaultValue)
        {
            if(this.HasDefaultFunction == true)
            {
                // note: no need to check for FunctionDefaultInfo.IsStatic, but strongly typed invocation is preferred
                if(this.Base != null && this.FunctionDefaultAttribute?.IsStatic == false && this.FunctionDefaultInfo?.IsStatic == false)
                {
                    return this.FunctionDefaultInfo.Invoke(this.Base, new[] { value, defaultValue });
                }
                else if(this.DefaultValueAnyType == true)
                {
                    return this.ConverterAnyFunc.Invoke((TIn)value, (TArg)(defaultValue ?? default(TArg)));
                }
                return this.ConverterDefaultFunc.Invoke((TIn)value, (TOut)defaultValue);
            }
            else if(this.UseFunctionDefaultWrapper == true && this.ConverterFunc != null)
            {
                // Create a default-function wrapper using the existing TIn/TOut converter 
                try
                {
                    Func<TIn, TOut, TOut> defaultWrapper = this.FunctionDefaultWrapper<TIn, TOut>();
                    return (TOut)defaultWrapper((TIn)value, (TOut)defaultValue);
                }
                catch(Exception exc)
                {
                    throw new ConverterException(ConverterCause.ConvertFailed, exc);
                }
            }
            throw new ConverterException(ConverterCause.ConverterFunctionDefaultNull, "A default value exists but no conversion function taking a default-value is defined");
        }


        public TOut Convert(TIn valueTyped, TOut defaultValueTyped = default(TOut))
        {
            return (TOut)this.Convert(value: valueTyped, defaultValue: defaultValueTyped);
        }

        protected override void CheckConvertTypes(object value, object defaultValue)
        {
            if(value == null)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentNull);
            }

            if((value is TIn) == false)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentWrongType, $"Object is not of the type {this.From.FullName}.");
            }

            if(defaultValue != null && this.DefaultValueAnyType == false && (defaultValue is TOut) == false)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentWrongType, $"Object is not of the type {this.To.FullName}.");
            }
        }
    }
}