ConverterCollectionLookup.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.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;

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

    public static class ConverterCollectionLookup
    {

        public static Converter Get(this IQueryable<Converter> query, IConverter baseTypeInstance)
        {
            return query.Get(baseTypeInstance?.GetType());
        }

        public static Converter Get(this IQueryable<Converter> query, Type baseType)
        {

            var interfaceType = baseType?.GetTypeInfo()
                                .ImplementedInterfaces.ToList()
                                .FirstOrDefault(c => c.Name.StartsWith(nameof(IConverter)));
            if(interfaceType != null && interfaceType.IsConstructedGenericType)
            {
                var types = interfaceType.GenericTypeArguments;

                var converter = query.Get(types.First().GetTypeInfo(), types.Last().GetTypeInfo());
                return converter;
            }
            return null;
        }

        public static Converter Get(this IQueryable<Converter> query, Type typeFrom, Type typeTo)
        {
            return query.Get(typeFrom: typeFrom.GetTypeInfo(), typeTo: typeTo.GetTypeInfo());
        }

        public static Converter Get<TOut>(this IQueryable<Converter> query, object value, bool? hasDefault = null, bool loadOnDemand = false)
        {
            return query.Get(value?.GetType().GetTypeInfo(), typeof(TOut).GetTypeInfo(), hasDefaultFunction: hasDefault, loadOnDemand: loadOnDemand);
        }

        public static Converter Get<TIn, TOut>(this IQueryable<Converter> query, TIn value = default(TIn), Type typeArgument = null, bool? hasDefault = null, bool loadOnDemand = false)
        {
            return query.Get(typeof(TIn).GetTypeInfo(), typeof(TOut).GetTypeInfo(), typeArgument: typeArgument?.GetTypeInfo(), hasDefaultFunction: hasDefault, loadOnDemand: loadOnDemand);
        }

        public static Converter Get<TIn, TArg, TOut>(this IQueryable<Converter> query, TIn value = default(TIn), TArg argument = default(TArg), TOut defaultValue = default(TOut), bool? hasDefault = null, bool loadOnDemand = false)
        {
            return query.Get(typeof(TIn).GetTypeInfo(), typeof(TOut).GetTypeInfo(), typeArgument: typeof(TArg).GetTypeInfo(), hasDefaultFunction: hasDefault, loadOnDemand: loadOnDemand);
        }

        public static Converter Get<TOut>(this IQueryable<Converter> query, Type typeFrom, Type typeArgument = null, bool? hasDefault = null, bool loadOnDemand = false)
        {
            return query.Get(typeFrom.GetTypeInfo(), typeof(TOut).GetTypeInfo(), typeArgument: typeArgument?.GetTypeInfo(), hasDefaultFunction: hasDefault, loadOnDemand: loadOnDemand);
        }

        public static Converter Get(this IQueryable<Converter> query, 
            TypeInfo typeFrom,
            TypeInfo typeTo,
            TypeInfo typeArgument = null,
            TypeInfo typeBase = null,
            bool? hasDefaultFunction = null,
            bool loadOnDemand = false,
            bool? isStandard = null,
            bool? typeFromIsGenericType = null,
            bool? typeToIsGenericType = null,
            string functionName = null,
            string attributeName = null,
            bool assignable = false, 
            bool withContext = false)
        {
            query = query.ApplyAllFilters(typeFrom: typeFrom, typeTo: typeTo, typeArgument: typeArgument, typeBase: typeBase, hasDefaultFunction: hasDefaultFunction,
                                            isStandard: isStandard, typeFromIsGenericType: typeFromIsGenericType, typeToIsGenericType: typeToIsGenericType, 
                                            functionName: functionName, attributeName: attributeName, assignableFrom: assignable, assignableTo: assignable, 
                                            assignableArgument: assignable, withContext: withContext);

            if(loadOnDemand == true && query.Any() == false && ((query as ConverterCollection) ?? ConverterCollection.CurrentInstance)?.LoadOnDemandConverter(typeTo?.AsType()) > 0)
            {
                query = query.WithFrom(typeFrom).WithTo(typeTo);
            }

            // with disambiguates and no specified type-argument, pick the most generic converter
            if(query.Count() > 1 && typeArgument == null)
            {
                query = query.WithArgument(typeof(object), assignable: false);
            }

            return query.FirstOrDefault();
        }

    }

}