ConverterExtension.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.Linq;
    using System.Reflection;

    using Core.TypeCast.Base;

    public static class ConverterExtension
    {
        public static Func<TIn, TOut, TOut> FunctionDefaultWrapper<TIn, TOut>(this Converter self)
        {
            if (self.Function == null)
            {
                return null;
            }
            Func<TIn, TOut> converter = (Func<TIn, TOut>)self.Function;
            Func<TIn, TOut, TOut> converterDefault = (value, defaultValue) =>
                {
                    TOut retvalue = default(TOut);
                    try
                    {
                        var result = converter(value);
                        retvalue = Equals(default(TOut), result) == true ? defaultValue : result;
                    }
                    catch (Exception exc)
                    {
                        throw new ConverterException(ConverterCause.ConverterWrapperError, exc);
                    }
                    return retvalue;
                };
            return converterDefault;
        }

        public static Func<TIn, TOut, TOut> FunctionDefaultWrapper<TIn, TOut>(this Converter<TIn, TOut> self)
        {
            return (self as Converter)?.FunctionDefaultWrapper<TIn, TOut>();
        }

        public static bool MergeStandard(this Converter self, Converter converter)
        {
            // check that either converter has a Function and DefaultFunction set
            if(self != null && self.Standard == true)
            {
                if((self.HasFunction == converter.HasFunction) && (self.HasDefaultFunction == converter.HasDefaultFunction))
                {
                    throw new ConverterCollectionException(ConverterCollectionCause.ConverterExists, self.ToString());
                }

                // merge the two converters together by using the existing and discarding the other
                if(self.HasDefaultFunction == false)
                {
                    self.FunctionDefault = converter.FunctionDefault;
                }
                else
                {
                    self.Function = converter.Function;
                }

                self.Attribute = self.Attribute ?? converter.Attribute;
                return true;
            }
            return false;
        }

        public static bool SetCollectionDefaults(this Converter self, ConverterCollection collection = null)
        {
            if(collection != null)
            {
                // add a collection reference to the converter
                self.Collection = collection;
            }

            if(self.Collection == null)
            {
                // set common collection settings according to the ConverterCollectionSettings
                self.DefaultValueAnyType |= self.Collection.Settings.DefaultValueAnyType;
                self.UseFunctionDefaultWrapper |= self.Collection.Settings.UseFunctionDefaultWrapper;
                return true;
            }
            return false;
        }

        public static void SetBaseType(this Converter self, Type baseType)
        {
            if(self.BaseType == null && baseType != null)
            {
                self.BaseType = baseType.GetTypeInfo();
            }
            else if(self.BaseType == null && baseType == null && self.HasFunction)
            {
                self.BaseType = ((self.Function ?? self.FunctionDefault) as Delegate)?
                                    .Target
                                    .GetType()
                                    .DeclaringType
                                    .GetTypeInfo();
            }
        }

        public static IQueryable<Converter> WithSameFromType(this Converter self)
        {
            if(self.Collection != null)
            {
                return self.Collection.Items.AsQueryable().WithFrom(self.From);
            }
            return null;
        }

        public static IQueryable<Converter> WithSameToType(this Converter self)
        {
            if(self.Collection != null)
            {
                return self.Collection.Items.AsQueryable().WithTo(self.To);
            }
            return null;
        }

        public static void MergeFromMethodAttribute(this Converter self, MethodInfo methodInfo)
        {
            var classAttribute = methodInfo.DeclaringType.GetTypeInfo().GetCustomAttribute<ConverterAttribute>();
            var methodAttribute = methodInfo.GetCustomAttribute<ConverterMethodAttribute>();

            // set function-alias for unique transformation function lookup
            self.Attribute = new ConverterAttribute(loadOnDemand: classAttribute?.LoadOnDemand ?? false, 
                name: String.IsNullOrWhiteSpace(classAttribute?.Name) ? methodAttribute?.Name : classAttribute.Name,
                nameSpace: methodInfo.DeclaringType.Namespace, 
                dependencyInjection: classAttribute?.DependencInjection ?? false);

            // set base-type delegate type used for unique transformation-lookup
            if(methodAttribute?.BaseType != null)
            {
                self.BaseType = self.BaseType ?? methodAttribute.BaseType.GetTypeInfo();
            }
        }
    }
}