Converter.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.Base
{
    using System;
    using System.Diagnostics;
    using System.Reflection;
    using System.Runtime.Serialization;

    [DebuggerDisplay("{DebuggerDisplay,nq}")]
    [DataContract(IsReference = false, Name = "BaseConverter", Namespace = nameof(Base))]
    public abstract class Converter : IConverter
    {
        private ConverterAttribute attribute;

        protected Converter(Type from, Type to, Type argument = null, Type baseType = null, ConverterAttribute attribute = null)
        {
            this.From = from?.GetTypeInfo();
            this.To = to?.GetTypeInfo();
            this.Argument = argument?.GetTypeInfo();
            this.BaseType = baseType?.GetTypeInfo();
            if(attribute != null)
            {
                this.Attribute = attribute;
                this.NameSpace = attribute.NameSpace;
            }
        }

        [DataMember]
        public TypeInfo Argument { get; set; }

        public virtual TypeInfo ArgumentStandard { get; } = typeof(object).GetTypeInfo();

        public ConverterAttribute Attribute
        {
            get
            {
                return this.attribute;
            }
            set
            {
                this.attribute = value;
            }
        }

        public object Base { get; set; }


        [DataMember]
        public TypeInfo BaseType { get; set; }

        public IConverterCollection Collection { get; set; }

        [DataMember]
        public bool AllowDisambiguates { get; set; }

        [DataMember]
        public bool DefaultValueAnyType { get; set; }

        [DataMember]
        public TypeInfo From { get; private set; }

        [DataMember]
        public object Function { get; set; }

        [DataMember]
        protected MethodInfo FunctionInfo { get; set; }

        [DataMember]
        public ConverterMethodAttribute FunctionAttribute { get; set; }

        [DataMember]
        public object FunctionDefault { get; set; }

        [DataMember]
        protected MethodInfo FunctionDefaultInfo { get; set; }

        [DataMember]
        public ConverterMethodAttribute FunctionDefaultAttribute { get; set; }

        [DataMember]
        public bool HasDefaultFunction
        {
            get
            {
                return this.FunctionDefault != null && this.FunctionDefault is Delegate;
            }
        }

        [DataMember]
        public bool HasDefaultFunctionOnly
        {
            get
            {
                return this.Function == null && this.HasDefaultFunction;
            }
        }

        [DataMember]
        public bool HasFunction
        {
            get
            {
                return (this.Function ?? this.FunctionDefault) != null && (this.Function ?? this.FunctionDefault) is Delegate;
            }
        }

        [DataMember]
        public bool Standard
        {
            get
            {
                if(typeof(MulticastDelegate).GetTypeInfo().IsAssignableFrom(this.BaseType) == true)
                {
                    return false;
                }
                return ((this.HasDefaultFunction == true) && (this.Argument == this.To))
                    || ((this.HasDefaultFunctionOnly == false) && (this.HasFunction == true) && (this.Argument == this.To || this.Argument == this.ArgumentStandard));
            }
        }

        [DataMember]
        public string NameSpace { get; private set; }

        [DataMember]
        public TypeInfo To { get; private set; }

        [DataMember]
        public bool UseFunctionDefaultWrapper { get; set; }

        private string DebuggerDisplay
        {
            get
            {
                return this.ToString();
            }
        }

        public abstract object Convert(object value, object defaultValue = null);

        public override string ToString()
        {
            return
                $"{this.GetType().Name}[({this.From?.Name}, {this.Argument?.Name}) => {this.To?.Name}] BaseType: {this.BaseType?.Name}, Attribute: {this.Attribute}";
        }

        public string ToString(bool fullName)
        {
            if(fullName == false)
            {
                return this.ToString();
            }

            return
                $"{this.GetType().FullName}[({this.From?.FullName}, {this.Argument?.FullName}) => {this.To?.FullName}] BaseType: {this.BaseType?.FullName}, Attribute: {this.Attribute}";
        }

        protected abstract void CheckConvertTypes(object value, object defaultValue);
    }
}