ConverterCollection.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.Collections;
    using System.Collections.Concurrent;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Threading;

    using Core.Extensions;
    using Core.Singleton;
    using Core.TypeCast.Base;


    [Singleton(disposable: true, createInternal: true, initByAttribute: true)]
    [System.Runtime.InteropServices.ComVisible(false)]
    public partial class ConverterCollection : Singleton<ConverterCollection>, IConverterCollection, IDisposable, IEnumerable<Converter>, IQueryable<Converter>
    {
        public ConverterCollectionSettings Settings { get; set; }

        private readonly Dictionary<string, List<Type>> loadOnDemandConverters;

        private int count;

        public ConverterCollection()
            : this(application: null, numberFormatDefault: null, converterClasses: null)
        {
        }

        public ConverterCollection(Type application)
            : this(application: application, numberFormatDefault: null, converterClasses: null)
        {
        }

        public ConverterCollection(Type application, Type converterClass, NumberFormatInfo numberFormatDefault = null)
            : this(application: application, numberFormatDefault: numberFormatDefault, converterClasses: converterClass)
        {
        }

        public ConverterCollection(Assembly assembly, NumberFormatInfo numberFormatDefault = null)
            : this(application: null, numberFormatDefault: numberFormatDefault, converterClasses: null)
        {
            this.Initialize(assembly);
        }

        public ConverterCollection(Type application = null, params Type[] converterClasses)
            : this(application: application, numberFormatDefault: null, converterClasses: converterClasses)
        {
        }

        public ConverterCollection(Type application = null, NumberFormatInfo numberFormatDefault = null, params Type[] converterClasses)
        {
            this.Settings = new ConverterCollectionSettings();
            this.loadOnDemandConverters = new Dictionary<string, List<Type>>();

            this.Factory = new ConverterFactory();
            this.FactoryBaseClass = new BaseClassFactoryRT();

            this.AssemblyInitialized = new ConcurrentDictionary<Assembly, bool>();
            this.ConverterClassInitialized = new ConcurrentDictionary<TypeInfo, bool>();
            this.ConstructorAddedClasses = new List<Type>();
            this.Items = new BlockingCollection<Converter>(boundedCapacity: this.Settings.BoundedCapacity);

            if(application != null)
            {
                ApplicationNameSpace = application.Namespace;
                this.Initialize(ApplicationNameSpace);
            }

            if(numberFormatDefault as NumberFormatInfo != null)
            {
                this.Settings.NumberFormat = numberFormatDefault;
            }

            if(converterClasses != null)
            {
                foreach(var converterClass in converterClasses)
                {
                    if(converterClass != null && converterClass.GetTypeInfo().IsClass == true)
                    {
                        ConstructorAddedClasses.Add(converterClass);

                        this.AddAllConvertersByAttribute(converterClass.GetTypeInfo());
                    }
                }
            }

            // Load any declared converters from the own assembly
            this.Initialize(this.GetType().GetTypeInfo()?.Assembly.DefinedTypes);
        }

        public ConverterFactory Factory { get; }

        public BaseClassFactoryRT FactoryBaseClass { get; }

        public string ApplicationNameSpace { get; set; }

        public List<Type> ConstructorAddedClasses { get; }

        public ConcurrentDictionary<Assembly, bool> AssemblyInitialized { get; }

        public ConcurrentDictionary<TypeInfo, bool> ConverterClassInitialized { get; }

        public int Count
        {
            get
            {
                return this.Items.Count;
            }

            private set
            {
                if(value != this.count)
                {
                    OnPropertyChanged();
                    this.count = value;
                }
            }
        }

        public BlockingCollection<Converter> Items { get; }

        public bool IsAddingCompleted
        {
            get
            {
                return this.Items.IsAddingCompleted;
            }
            set
            {
                if(value == true)
                {
                    this.Items.CompleteAdding();
                }

            }
        }

        #region Implementation of IQueryable<Converter>

        public Type ElementType
        {
            get
            {
                return this.Items.AsQueryable().ElementType;
            }
        }

        public Expression Expression
        {
            get
            {
                return this.Items.AsQueryable().Expression;
            }
        }

        public IQueryProvider Provider
        {
            get
            {
                return this.Items.AsQueryable().Provider;
            }
        }

        #endregion

        public Converter this[int index]
        {
            get
            {
                return this.Items?.Skip(index)?.FirstOrDefault();
            }
        }

        public Converter this[Type typeFrom, Type typeTo]
        {
            get
            {
                return this.Get(typeFrom.GetTypeInfo(), typeTo.GetTypeInfo());
            }
        }

        public Converter this[TypeInfo typeFrom, TypeInfo typeTo]
        {
            get
            {
                return this.Get(typeFrom, typeTo);
            }
        }


        public IEnumerable<Converter> this[TypeInfo typeFrom]
        {
            get
            {
                return this.WithFrom(typeFrom);
            }
        }

        public AddBuilder<TBase> AddStart<TBase>(ConverterCollectionSettings settings = null,
            CancellationToken cancellationToken = default(CancellationToken)) where TBase : class
        {
            return new AddBuilder<TBase>(this, settings: settings, cancellationToken: ref cancellationToken);
        }

        public AddBuilder<TBase> AddStart<TBase>(ConverterCollectionSettings settings,
            ref CancellationToken cancellationToken) where TBase : class
        {
            return new AddBuilder<TBase>(this, settings: settings, cancellationToken: ref cancellationToken);
        }

        public IConverterCollection Add<TIn, TOut>(
            Func<TIn, TOut> converterAction,
            Type baseType = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            var converter = Factory.Create<TIn, TOut>(converterAction);
            return this.Add(converter: converter, baseType: baseType, cancellationToken: cancellationToken);
        }


        public IConverterCollection Add<TIn, TOut>(
            Func<TIn, TOut> converterActionForward,
            Func<TOut, TIn> converterActionBackward,
            Type baseType = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            this.Add(converterAction: converterActionForward, baseType: baseType, cancellationToken: cancellationToken);
            return this.Add(converterAction: converterActionBackward, baseType: baseType, cancellationToken: cancellationToken);
        }

        public IConverterCollection Add<TIn, TOut, TBase>(Func<TIn, TOut> converterAction, CancellationToken cancellationToken = default(CancellationToken))
            where TBase : class
        {
            var converter = Factory.Create<TIn, TOut>(converterAction);
            return this.Add(converter: converter, baseType: typeof(TBase), cancellationToken: cancellationToken);
        }

        public IConverterCollection Add<TIn, TOut, TBase>(
            Func<TIn, TOut, TOut> converterActionDefault,
            CancellationToken cancellationToken = default(CancellationToken)) where TBase : class
        {
            var converter = Factory.Create<TIn, TOut>(converterActionDefault);
            return this.Add(converter: converter, baseType: typeof(TBase), cancellationToken: cancellationToken);
        }

        public IConverterCollection Add<TIn, TArg, TOut, TBase>(
            Func<TIn, TArg, TOut> converterActionAny,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if(typeof(TOut) == typeof(TArg))
            {
                var converter = Factory.Create<TIn, TOut>((Func<TIn, TOut, TOut>)(object)converterActionAny);
                return this.Add(converter: converter, baseType: typeof(TBase), cancellationToken: cancellationToken);
            }
            return this.Add(converterDelegate: converterActionAny, baseType: typeof(TBase), cancellationToken: cancellationToken);
        }

        public IConverterCollection Add<TIn, TArg, TOut>(
            Func<TIn, TArg, TOut> converterActionAny,
            Type baseType = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if(typeof(TOut) == typeof(TArg))
            {
                var converter = Factory.Create<TIn, TOut>((Func<TIn, TOut, TOut>)(object)converterActionAny);
                return this.Add(converter: converter, baseType: baseType, cancellationToken: cancellationToken);
            }
            return this.Add(converterDelegate: converterActionAny, baseType: baseType, cancellationToken: cancellationToken);
        }


        public IConverterCollection Add<TBase>(object converterDelegate, CancellationToken cancellationToken = default(CancellationToken)) where TBase : class
        {
            return this.Add(converterDelegate: converterDelegate, baseType: typeof(TBase), cancellationToken: cancellationToken);
        }

        public IConverterCollection Add(object converterDelegate, Type baseType = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            if(converterDelegate == null)
            {
                throw new ConverterCollectionException(ConverterCollectionCause.ConverterArgumentNull, $"{nameof(converterDelegate)} must not be null and of Type Delegate");
            }
            if((converterDelegate is Delegate) == false)
            {
                throw new ConverterCollectionException(ConverterCollectionCause.ConverterArgumentWrongType, $"{nameof(converterDelegate)} must be a `Delegate` Type");
            }

            if(baseType == null)
            {
                baseType = ((Delegate)converterDelegate).Target.GetType().DeclaringType;
            }

            var methodInfo = ((Delegate)converterDelegate).GetMethodInfo(); //type.GetDeclaredMethod("Invoke");
            return this.Add(methodInfo: methodInfo, converterDelegate: converterDelegate, baseType: baseType, cancellationToken: cancellationToken);
        }

        public IConverterCollection Add(MethodInfo methodInfo, object converterDelegate = null, Type baseType = null, object baseInstance = null,
            CancellationToken cancellationToken = default(CancellationToken))
        {

            var converter = this.Factory.Create(methodInfo, converterDelegate);

            if(converter != null)
            {
                converter.Base = baseInstance;
                return this.Add(converter: converter, baseType: baseType, cancellationToken: cancellationToken);
            }
            else
            {
                throw new ConverterException(ConverterCause.ConverterCollectionAddFailed);
            }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2200:RethrowToPreserveStackDetails")]
        public IConverterCollection Add(Converter converter, Type baseType = null, bool allowDisambiguates = false, CancellationToken cancellationToken = default(CancellationToken))
        {
            if(converter == null)
            {
                throw new ConverterCollectionException(ConverterCollectionCause.ConverterArgumentNull);
            }

            if(converter.HasFunction == false)
            {
                throw new ConverterCollectionException(ConverterCollectionCause.ConverterFunctionsNull);
            }

            try
            {
                converter.SetCollectionDefaults(this);

                if(allowDisambiguates == false && baseType?.GetTypeInfo().BaseType == typeof(MulticastDelegate))
                {
                    allowDisambiguates = true;
                }

                converter.AllowDisambiguates = allowDisambiguates;
                // if there is already a standard converter try to merge them. The condition is that the converter argument type match or is not used
                if(allowDisambiguates == false && converter.Standard)
                {
                    var converterLookup = this.Get(typeFrom: converter.From, typeTo: converter.To, typeArgument: typeof(object).GetTypeInfo(), loadOnDemand: false, isStandard: true);
                    try
                    {
                        if(converterLookup?.MergeStandard(converter) == true)
                        {
                            return this;
                        }
                    }
                    catch(ConverterCollectionException exc)
                    {
                        exc.Cause |= ConverterCollectionCause.AddFailed;
                        throw exc;
                    }
                }
                // update the base-type and thus the attribute access of the converter
                converter.SetBaseType(baseType);

                this.Items.TryAdd(converter, 100, cancellationToken);
                OnPropertyChanged(converter);
            }
            catch(ConverterCollectionException)
            {
                throw;
            }
            catch(ConverterException)
            {
                throw;
            }
            catch(Exception exc)
            {
                throw new ConverterException(ConverterCause.ConverterCollectionAddFailed, exc);
            }

            return this;
        }

        public bool CanConvertFrom(Type typeFrom)
        {
            return this.WithFrom(typeFrom.GetTypeInfo()).FirstOrDefault() != null;
        }

        public bool CanConvertFrom<TIn>()
        {
            return this.WithFrom(typeof(TIn).GetTypeInfo()).FirstOrDefault() != null;
        }

        public bool CanConvertTo(Type typeTo)
        {
            return this.WithTo(typeTo.GetTypeInfo()).FirstOrDefault() != null;
        }

        public bool CanConvertTo<TOut>()
        {
            return this.WithTo(typeof(TOut).GetTypeInfo()).FirstOrDefault() != null;
        }

        public ConverterAttribute ConverterAttributeFromIConverter(TypeInfo baseType, ConverterAttribute attribute = null, bool update = false)
        {
            if(baseType == null || (attribute != null && update == false))
            {
                return attribute;
            }

            attribute = attribute ?? new ConverterAttribute();

            attribute.BaseType = baseType;
            // look up a possible converter candidate with generic IConverter<,> support
            var converter = this.Get(baseType.AsType());
            if(converter != null && (converter.Attribute == null || converter.Attribute != null && update == true))
            {
                converter.Attribute = attribute;
            }

            return attribute;
        }

        public int LoadOnDemandConverter(Type typeTo)
        {
            var nameSpace = typeTo?.Namespace.Split('.').Last();
            if(nameSpace != null && this.loadOnDemandConverters.ContainsKey(nameSpace))
            {
                var loaded = this.loadOnDemandConverters[nameSpace].Select(this.CreateConverterClassInstance).Count();
                this.loadOnDemandConverters.Remove(nameSpace);
                return loaded;
            }
            return 0;
        }


        private static bool AutoInitialized;

        public static void AutoInitialize()
        {
            // is the ConverterCollection Initialized?
            if(AutoInitialized == false && CurrentInstance.Settings.AutoInitialize == true)
            {
                try
                {
                    var getEntryAssembly = typeof(Assembly).GetRuntimeMethods().FirstOrDefault(m => m.Name.Equals("GetEntryAssembly"));
                    if(getEntryAssembly != null)
                    {
                        var assembly = getEntryAssembly.Invoke(null, null) as Assembly;
                        CurrentInstance.Initialize(assembly);
                        CurrentInstance.ApplicationNameSpace = assembly?.GetNamespacesByLevel(0)?.FirstOrDefault();
                    }
                    // set as initialized regardless of success, to run only once
                    AutoInitialized = true;
                }
                catch(Exception exc)
                {
                    throw new ConverterException(ConverterCause.ConverterAutoInitializationFailed, exc);
                }
            }
        }

        public void Initialize(string applicationNameSpace)
        {
            IEnumerable<TypeInfo> types = Assembly.Load(new AssemblyName(applicationNameSpace)).DefinedTypes;
            this.Initialize(types);
        }

        public void Initialize(Type applicationClass)
        {
            if(applicationClass != null)
            {
                var assembly = applicationClass.GetTypeInfo().Assembly;
                this.Initialize(new[] { assembly });
            }
        }

        public void Initialize(Assembly assembly)
        {
            this.Initialize(new[] { assembly });
        }

        public void Initialize(Assembly[] assemblies)
        {
            foreach(var assembly in assemblies)
            {
                if(assembly == null || this.AssemblyInitialized.ContainsKey(assembly) == true)
                {
                    continue;
                }

                var types = assembly.GetAtributedTypes<ConverterAttribute>().ToArray();
                this.Initialize(types);
            }
        }

        public void Initialize(IEnumerable<TypeInfo> types)
        {
            foreach(var type in types)
            {
                this.AddAllConvertersByAttribute(type);
            }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "<Items>k__BackingField")]
        protected override void Dispose(bool disposing)
        {
            this.Items.Dispose();
            base.Dispose(disposing);
        }

        protected bool SetAssemblyInitialized(TypeInfo type)
        {
            return this.AssemblyInitialized.AddOrUpdate(type.Assembly, true, (oldkey, oldval) => true);
        }

        protected bool SetConverterClassInitialized(TypeInfo converterClass)
        {
            return this.ConverterClassInitialized.AddOrUpdate(converterClass, true, (oldkey, oldval) => true);
        }

        private object CreateConverterClassInstance(Type converterClass)
        {
            object customConverter;

            customConverter = this.FactoryBaseClass.Create(converterClass, this);
            this.SetConverterClassInitialized(converterClass.GetTypeInfo());

            return customConverter;
        }


        private bool AddAllConvertersByAttribute(TypeInfo type)
        {
            int count = this.Count;
            object converterCustom = null;

            if(ConstructorAddedClasses?.Contains(type.AsType()) == false)
            {
                var attribute = type.GetCustomAttribute<ConverterAttribute>();
                if(attribute == null)
                {
                    if(type.IsClass == true && type.ImplementedInterfaces.Contains(typeof(IConverter)) == true)
                    {
                        attribute = this.ConverterAttributeFromIConverter(type, attribute, update: true);
                    }
                    // the type is not a converter, let's return
                    return false;
                }

                if(attribute?.LoadOnDemand == true)
                {
                    if(this.loadOnDemandConverters?.ContainsKey(attribute.NameSpace) == false)
                    {
                        this.loadOnDemandConverters.Add(attribute.NameSpace, new List<Type>());
                    }

                    if(this.loadOnDemandConverters[attribute.NameSpace]?.Contains(type.AsType()) == false)
                    {
                        this.loadOnDemandConverters[attribute.NameSpace].Add(type.AsType());
                    }

                    return false;
                }

                if(attribute?.DependencInjection == true)
                {
                    converterCustom = this.CreateConverterClassInstance(type.AsType());
                }
            }

            // discover attributed methods
            foreach(var declaredMethod in type.DeclaredMethods)
            {
                var customAttribute = declaredMethod.GetCustomAttribute<ConverterMethodAttribute>() as ConverterMethodAttribute;
                if(customAttribute != null)
                {
                    // create a wrapper taking the own class-instance as first argument for methods that are attributed by `ConverterMethod` 
                    // and do not have any arguments or `PassInstance` set to `true`
                    if((declaredMethod.IsStatic == false && declaredMethod.GetParameters().Length == 0) || customAttribute.PassInstance == true)
                    {
                        Converter converter = this.Factory.CreateWrapper(type, declaredMethod);
                        this.Add(converter: converter, baseType: type.AsType());
                    }
                    else
                    {
                        if(converterCustom == null)
                        {
                            converterCustom = this.CreateConverterClassInstance(type.AsType());
                        }
                        if(converterCustom != null)
                        {
                            this.Add(methodInfo: declaredMethod, baseType: type.AsType(), baseInstance: converterCustom);
                        }
                    }
                }
            }

            this.SetAssemblyInitialized(type);
            return count != this.Count;
        }

        #region Implementation of IEnumerable

        public IEnumerator<Converter> GetEnumerator()
        {
            var enumerator = this.Items as IEnumerable<Converter>;//.GetConsumingEnumerable();
            return enumerator.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)this.Items).GetEnumerator();
        }

        #endregion
    }
}