ConverterCollectionFilters.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;

    public static class ConverterCollectionFilters
    {
        private static TypeInfo objectTypeInfo = typeof(object).GetTypeInfo();
        private static TypeInfo convertContexTypeInfo = typeof(IConvertContext).GetTypeInfo();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithFrom(this IQueryable<Converter> query, TypeInfo typeFrom, bool assignable = false)
        {
            if(typeFrom != null)
            {
                query = WithAssignable(query, c => c.From == typeFrom, c => c.From.IsSuperOrSubType(typeFrom), typeFrom, assignable);
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithFrom(this IQueryable<Converter> query, Type typeFrom, bool assignable = false)
        {
            return WithFrom(query, typeFrom?.GetTypeInfo(), assignable);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithTo(this IQueryable<Converter> query, TypeInfo typeTo, bool assignable = false)
        {
            if(typeTo != null)
            {
                query = WithAssignable(query, c => c.To == typeTo, c => c.To.IsSuperOrSubType(typeTo), typeTo, assignable);
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithTo(this IQueryable<Converter> query, Type typeTo, bool assignable = false)
        {
            return WithTo(query, typeTo?.GetTypeInfo(), assignable);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithBaseType(this IQueryable<Converter> query, TypeInfo typeBase, bool assignable = false)
        {
            if(typeBase != null && typeBase.AsType() != typeof(object))
            {
                query = WithAssignable(query, c => c.BaseType == typeBase, c => c.BaseType.IsSuperOrSubType(typeBase), typeBase, assignable);
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithBaseType(this IQueryable<Converter> query, Type typeBase, bool assignable = false)
        {
            return WithBaseType(query, typeBase?.GetTypeInfo(), assignable);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithArgument(this IQueryable<Converter> query, TypeInfo typeArgument, bool assignable = false, bool withContext = false)
        {
            // extend converters taking a context to converters with object argument
            if(withContext == true)
            {
                query = query.Where(c => c.Argument == objectTypeInfo || c.Argument.IsSuperOrSubType(convertContexTypeInfo));
            }
            else if(typeArgument != null && (assignable == false || typeArgument != objectTypeInfo))
            {
                query = WithAssignable(query, c => c.Argument == typeArgument, c => c.Argument.IsSuperOrSubType(typeArgument), typeArgument, assignable);
            }
            
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithArgument(this IQueryable<Converter> query, Type typeArgument, bool assignable = true, bool withContext = false)
        {
            return WithArgument(query, typeArgument?.GetTypeInfo(), assignable, withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static IQueryable<Converter> WithAssignable(IQueryable<Converter> query, Expression<Func<Converter, bool>> predicate, Expression<Func<Converter, bool>> predicateAssignable, TypeInfo type, bool assignable)
        {
            var testQuery = query.Where(predicate);
            if((type == objectTypeInfo || testQuery.Any()) && assignable == false)
            {
                query = testQuery;
            }
            else
            {
                // check for interfaces, sub-types ...
                query = query.Where(predicateAssignable);
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithStandard(this IQueryable<Converter> query, bool? isStandard = true)
        {
            if(isStandard != null)
            {
                query = query.Where(c => c.Standard == isStandard);
            }
            return query;
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithFromIsGenericType(this IQueryable<Converter> query, bool? typeFromIsGenericType = true)
        {
            if(typeFromIsGenericType != null)
            {
                query = query.Where(c => c.From.IsGenericType == typeFromIsGenericType);
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithToIsGenericType(this IQueryable<Converter> query, bool? typeToIsGenericType = true)
        {
            if(typeToIsGenericType != null)
            {
                query = query.Where(c => c.From.IsGenericType == typeToIsGenericType);
            }
            return query;
        }

        //(converter.Function as Delegate).Method.Name
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithFunctionName(this IQueryable<Converter> query, string containedName = null)
        {
            if(containedName != null)
            {
                query = query.Where(c => (c.Function != null && (c.Function as Delegate).GetMethodInfo().Name.Contains(containedName) == true) ||
                                         (c.FunctionDefault != null && (c.FunctionDefault as Delegate).GetMethodInfo().Name.Contains(containedName) == true)
                );
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithConverterAttributeName(this IQueryable<Converter> query, string containedName = null, bool caseSensitive = false)
        {
            if(string.IsNullOrWhiteSpace(containedName) == false)
            {
                if(caseSensitive == true)
                {
                    query = query.Where(c => (c.Attribute != null && c.Attribute.Name.ToLowerInvariant().Equals(containedName.ToLowerInvariant()) == true));
                }
                else
                {
                    query = query.Where(c => (c.Attribute != null && c.Attribute.Name.Equals(containedName) == true));
                }
            }
            return query;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IQueryable<Converter> WithDefaultFunction(this IQueryable<Converter> query, bool? hasDefaultFunction = true)
        {
            if(hasDefaultFunction != null)
            {
                query = query.Where(c => c.HasDefaultFunction == hasDefaultFunction);
            }
            return query;
        }

        public static IQueryable<Converter> ApplyAllFilters(
            this IQueryable<Converter> query,
            TypeInfo typeFrom = null,
            TypeInfo typeTo = null,
            TypeInfo typeArgument = null,
            TypeInfo typeBase = null,
            bool? hasDefaultFunction = null,
            bool? isStandard = null,
            bool? typeFromIsGenericType = null,
            bool? typeToIsGenericType = null,
            string functionName = null,
            string attributeName = null,
            bool assignableFrom = false,
            bool assignableTo = false,
            bool assignableArgument = false,
            bool assignableBaseType = false,
            bool withContext = false)
        {
            var queryFiltered = query
                        .WithFrom(typeFrom, assignableFrom)
                        .WithTo(typeTo, assignableTo)
                        .WithArgument(typeArgument, assignableArgument, withContext)
                        .WithBaseType(typeBase, assignableBaseType)
                        .WithStandard(isStandard)
                        .WithDefaultFunction(hasDefaultFunction)
                        .WithFromIsGenericType(typeFromIsGenericType)
                        .WithToIsGenericType(typeToIsGenericType)
                        .WithFunctionName(functionName)
                        .WithConverterAttributeName(attributeName);

            // All converters are contained in Converter_T3's with the argument set as default to: `object` or to `TOut` with a generic Converter.Function
            if(typeBase == null && queryFiltered.Count() > 1)
            {
                typeArgument = typeArgument ?? objectTypeInfo;

                queryFiltered = queryFiltered.WithArgument(typeArgument, assignableArgument);
            }
            return queryFiltered;
        }

    }

}