wip

MapsterMapper · May 26, 2017 · cb2b752 · cb2b752
1 parent c436564
commit cb2b752
Show file tree

Hide file tree

Showing 19 changed files with 266 additions and 152 deletions.
diff --git a/src/Mapster/Adapters/BaseAdapter.cs b/src/Mapster/Adapters/BaseAdapter.cs
@@ -13,12 +13,12 @@ public abstract class BaseAdapter
         protected virtual int Score => 0;
         protected virtual bool CheckExplicitMapping => true;
 
-        public virtual int? Priority(Type sourceType, Type destinationType, MapType mapType)
+        public virtual int? Priority(PreCompileArgument arg)
         {
-            return CanMap(sourceType, destinationType, mapType) ? this.Score : (int?)null;
+            return CanMap(arg) ? this.Score : (int?)null;
         }
 
-        protected abstract bool CanMap(Type sourceType, Type destinationType, MapType mapType);
+        protected abstract bool CanMap(PreCompileArgument arg);
 
         public LambdaExpression CreateAdaptFunc(CompileArgument arg)
         {
@@ -87,7 +87,7 @@ protected virtual Expression CreateExpressionBody(Expression source, Expression
         {
             if (this.CheckExplicitMapping
                 && arg.Context.Config.RequireExplicitMapping
-                && !arg.Context.Config.RuleMap.ContainsKey(new TypeTuple(arg.SourceType, arg.DestinationType)))
+                && !arg.ExplicitMapping)
             {
                 throw new InvalidOperationException("Implicit mapping is not allowed (check GlobalSettings.RequireExplicitMapping) and no configuration exists");
             }

diff --git a/src/Mapster/Adapters/BaseAfterMapper.cs b/src/Mapster/Adapters/BaseAfterMapper.cs
@@ -7,12 +7,12 @@ public abstract class BaseAfterMapper
     {
         protected virtual int Score => 0;
 
-        public virtual int? Priority(Type sourceType, Type destinationType, MapType mapType)
+        public virtual int? Priority(PreCompileArgument arg)
         {
-            return CanMap(sourceType, destinationType, mapType) ? this.Score : (int?)null;
+            return CanMap(arg) ? this.Score : (int?)null;
         }
 
-        protected abstract bool CanMap(Type sourceType, Type destinationType, MapType mapType);
+        protected abstract bool CanMap(PreCompileArgument arg);
 
         public LambdaExpression CreateAfterMapFunc(CompileArgument arg)
         {

diff --git a/src/Mapster/Adapters/ClassAdapter.cs b/src/Mapster/Adapters/ClassAdapter.cs
@@ -18,12 +18,9 @@ internal class ClassAdapter : BaseClassAdapter
     {
         protected override int Score => -150;
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
-            if (sourceType == typeof(string) || sourceType == typeof(object))
-                return false;
-
-            if (!destinationType.IsPoco())
+            if (!arg.DestinationType.IsPoco())
                 return false;
 
             return true;

diff --git a/src/Mapster/Adapters/CollectionAdapter.cs b/src/Mapster/Adapters/CollectionAdapter.cs
@@ -13,11 +13,11 @@ internal class CollectionAdapter : BaseAdapter
         protected override int Score => -125;
         protected override bool CheckExplicitMapping => false;
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
-            return sourceType.IsCollection()
-                   && destinationType.IsCollection()
-                   && destinationType.IsListCompatible();
+            return arg.SourceType.IsCollection()
+                   && arg.DestinationType.IsCollection()
+                   && arg.DestinationType.IsListCompatible();
         }
 
         private static Expression CreateCountExpression(Expression source, bool allowCountAll)

diff --git a/src/Mapster/Adapters/DelegateAdapter.cs b/src/Mapster/Adapters/DelegateAdapter.cs
@@ -12,7 +12,7 @@ public DelegateAdapter(LambdaExpression lambda)
             _lambda = lambda;
         }
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
             throw new NotImplementedException();
         }

diff --git a/src/Mapster/Adapters/DictionaryAdapter.cs b/src/Mapster/Adapters/DictionaryAdapter.cs
@@ -12,12 +12,9 @@ internal class DictionaryAdapter : ClassAdapter
     {
         protected override int Score => -124;
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
-            if (sourceType == typeof (string) || sourceType == typeof (object))
-                return false;
-
-            var dictType = destinationType.GetDictionaryType();
+            var dictType = arg.DestinationType.GetDictionaryType();
             return dictType?.GetGenericArguments()[0] == typeof (string);
         }
 

diff --git a/src/Mapster/Adapters/ObjectAdapter.cs b/src/Mapster/Adapters/ObjectAdapter.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Linq.Expressions;
+
+namespace Mapster.Adapters
+{
+    internal class ObjectAdapter : BaseAdapter
+    {
+        protected override int Score => -111;
+
+        protected override bool CanMap(PreCompileArgument arg)
+        {
+            return arg.SourceType == typeof(object) || arg.DestinationType == typeof(object);
+        }
+
+        protected override Expression CreateBlockExpression(Expression source, Expression destination, CompileArgument arg)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override Expression CreateInlineExpression(Expression source, CompileArgument arg)
+        {
+    //        object, T
+
+    //if (src.GetType() == typeof(object))
+    //            return (T)src
+
+    //return src.Adapt<T>();
+
+    //        poco, object
+
+    //return (object)src.Adapt<T, T>();
+
+    //        object, object
+
+    //if (src.GetType() == typeof(object))
+    //            return src;
+    //        return src.Adapt(src.GetType(), src.GetType());
+        }
+    }
+}
diff --git a/src/Mapster/Adapters/PrimitiveAdapter.cs b/src/Mapster/Adapters/PrimitiveAdapter.cs
@@ -1,4 +1,6 @@
-using System;
+using Mapster.Utils;
+using System;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -9,7 +11,7 @@ internal class PrimitiveAdapter : BaseAdapter
         protected override int Score => -200;
         protected override bool CheckExplicitMapping => false;
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
             return true;
         }
@@ -25,7 +27,7 @@ protected override Expression CreateExpressionBody(Expression source, Expression
                 {
                     convert = Expression.Convert(convert, sourceType.GetGenericArguments()[0]);
                 }
-                convert = ReflectionUtils.BuildUnderlyingTypeConvertExpression(convert, sourceType, destinationType, arg.Settings);
+                convert = ConvertType(convert, arg);
                 if (convert.Type != destinationType)
                     convert = Expression.Convert(convert, destinationType);
 
@@ -41,6 +43,66 @@ protected override Expression CreateExpressionBody(Expression source, Expression
             return convert;
         }
 
+        protected virtual Expression ConvertType(Expression source, CompileArgument arg)
+        {
+            var srcType = arg.SourceType.UnwrapNullable();
+            var destType = arg.DestinationType.UnwrapNullable();
+
+            if (srcType == destType)
+                return source;
+
+            if (destType.GetTypeInfo().IsEnum && srcType.GetTypeInfo().IsEnum && arg.Settings.MapEnumByName == true)
+            {
+                var method = typeof(Enum<>).MakeGenericType(srcType).GetMethod("ToString", new[] { srcType });
+                var tostring = Expression.Call(method, source);
+                var methodParse = typeof(Enum<>).MakeGenericType(destType).GetMethod("Parse", new[] { typeof(string) });
+
+                return Expression.Call(methodParse, tostring);
+            }
+
+            if (IsObjectToPrimitiveConversion(srcType, destType))
+            {
+                return CreateConvertMethod(_primitiveTypes[destType], srcType, destType, source);
+            }
+
+            //try using type casting
+            try
+            {
+                return Expression.Convert(source, destType);
+            }
+            catch
+            {
+                // ignored
+            }
+
+            if (!srcType.IsConvertible())
+                throw new InvalidOperationException("Cannot convert immutable type, please consider using 'MapWith' method to create mapping");
+
+            //using Convert
+            if (_primitiveTypes.ContainsKey(destType))
+            {
+                return CreateConvertMethod(_primitiveTypes[destType], srcType, destType, source);
+            }
+
+            var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new[] { typeof(object), typeof(Type) });
+            return Expression.Convert(Expression.Call(changeTypeMethod, Expression.Convert(source, typeof(object)), Expression.Constant(destType)), destType);
+        }
+
+        private static bool IsObjectToPrimitiveConversion(Type sourceType, Type destinationType)
+        {
+            return (sourceType == typeof(object)) && _primitiveTypes.ContainsKey(destinationType);
+        }
+
+        private static Expression CreateConvertMethod(string name, Type srcType, Type destType, Expression source)
+        {
+            var method = typeof(Convert).GetMethod(name, new[] { srcType });
+            if (method != null)
+                return Expression.Call(method, source);
+
+            method = typeof(Convert).GetMethod(name, new[] { typeof(object) });
+            return Expression.Convert(Expression.Call(method, Expression.Convert(source, typeof(object))), destType);
+        }
+
         protected override Expression CreateBlockExpression(Expression source, Expression destination, CompileArgument arg)
         {
             throw new NotImplementedException();
@@ -50,5 +112,22 @@ protected override Expression CreateInlineExpression(Expression source, CompileA
         {
             throw new NotImplementedException();
         }
+
+        // Primitive types with their conversion methods from System.Convert class.
+        private static Dictionary<Type, string> _primitiveTypes = new Dictionary<Type, string>() {
+            { typeof(bool), "ToBoolean" },
+            { typeof(short), "ToInt16" },
+            { typeof(int), "ToInt32" },
+            { typeof(long), "ToInt64" },
+            { typeof(float), "ToSingle" },
+            { typeof(double), "ToDouble" },
+            { typeof(decimal), "ToDecimal" },
+            { typeof(ushort), "ToUInt16" },
+            { typeof(uint), "ToUInt32" },
+            { typeof(ulong), "ToUInt64" },
+            { typeof(byte), "ToByte" },
+            { typeof(sbyte), "ToSByte" },
+            { typeof(DateTime), "ToDateTime" }
+        };
     }
 }
diff --git a/src/Mapster/Adapters/RecordTypeAdapter.cs b/src/Mapster/Adapters/RecordTypeAdapter.cs
@@ -12,12 +12,9 @@ internal class RecordTypeAdapter : BaseClassAdapter
     {
         protected override int Score => -151;
 
-        protected override bool CanMap(Type sourceType, Type destinationType, MapType mapType)
+        protected override bool CanMap(PreCompileArgument arg)
         {
-            if (sourceType == typeof (string) || sourceType == typeof (object))
-                return false;
-
-            if (!destinationType.IsRecordType())
+            if (!arg.DestinationType.IsRecordType())
                 return false;
 
             return true;

diff --git a/src/Mapster/Adapters/StringAdapter.cs b/src/Mapster/Adapters/StringAdapter.cs
@@ -0,0 +1,67 @@
+using Mapster.Utils;
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Mapster.Adapters
+{
+    internal class StringAdapter : PrimitiveAdapter
+    {
+        protected override int Score => -110;
+        protected override bool CheckExplicitMapping => false;
+
+        protected override bool CanMap(PreCompileArgument arg)
+        {
+            return arg.SourceType == typeof(string) || arg.DestinationType == typeof(string);
+        }
+
+        protected override Expression CreateExpressionBody(Expression source, Expression destination, CompileArgument arg)
+        {
+            var sourceType = arg.SourceType;
+            var destinationType = arg.DestinationType;
+
+            if (sourceType == destinationType)
+                return source;
+
+            if (destinationType == typeof(string))
+            {
+                if (sourceType.GetTypeInfo().IsEnum)
+                {
+                    var method = typeof(Enum<>).MakeGenericType(sourceType).GetMethod("ToString", new[] { sourceType });
+                    return Expression.Call(method, source);
+                }
+                else
+                {
+                    var method = sourceType.GetMethod("ToString", Type.EmptyTypes);
+                    return Expression.Call(source, method);
+                }
+            }
+            else //if (sourceType == typeof(string))
+            {
+                if (destinationType.GetTypeInfo().IsEnum)
+                {
+                    var method = typeof(Enum<>).MakeGenericType(destinationType).GetMethod("Parse", new[] { typeof(string) });
+                    return Expression.Call(method, source);
+                }
+                else
+                {
+                    var method = destinationType.GetMethod("Parse", new[] { typeof(string) });
+                    if (method != null)
+                        return Expression.Call(method, source);
+                }
+            }
+
+            return base.ConvertType(source, arg);
+        }
+
+        protected override Expression CreateBlockExpression(Expression source, Expression destination, CompileArgument arg)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override Expression CreateInlineExpression(Expression source, CompileArgument arg)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/Mapster/Compile/CompileArgument.cs b/src/Mapster/Compile/CompileArgument.cs
@@ -7,6 +7,7 @@ public class CompileArgument
         public Type SourceType;
         public Type DestinationType;
         public MapType MapType;
+        public bool ExplicitMapping;
         public TypeAdapterSettings Settings;
         public CompileContext Context;
     }

diff --git a/src/Mapster/Compile/PreCompileArgument.cs b/src/Mapster/Compile/PreCompileArgument.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Mapster
+{
+    public class PreCompileArgument
+    {
+        public Type SourceType;
+        public Type DestinationType;
+        public MapType MapType;
+        public bool ExplicitMapping;
+    }
+}
diff --git a/src/Mapster/Enums/AccessModifier.cs b/src/Mapster/Enums/AccessModifier.cs
@@ -9,6 +9,7 @@ public enum AccessModifier
         Private = 1,
         Protected = 2,
         Internal = 4,
+        ProtectedInternal = 6,
         Public = 8,
     }
 }
diff --git a/src/Mapster/Mapster.csproj b/src/Mapster/Mapster.csproj
@@ -62,12 +62,15 @@
     <Compile Include="Adapters\BaseClassAdapter.cs" />
     <Compile Include="Adapters\DelegateAdapter.cs" />
     <Compile Include="Adapters\DictionaryAdapter.cs" />
+    <Compile Include="Adapters\ObjectAdapter.cs" />
     <Compile Include="Adapters\RecordTypeAdapter.cs" />
+    <Compile Include="Adapters\StringAdapter.cs" />
     <Compile Include="Attributes\AdaptIgnoreAttribute.cs" />
     <Compile Include="Attributes\AdaptMemberAttribute.cs" />
     <Compile Include="Compile\CompileArgument.cs" />
     <Compile Include="Compile\CompileContext.cs" />
     <Compile Include="Compile\CompileException.cs" />
+    <Compile Include="Compile\PreCompileArgument.cs" />
     <Compile Include="Enums\EnumMappingStrategy.cs" />
     <Compile Include="Enums\MemberSide.cs" />
     <Compile Include="Interfaces\IApplyable.cs" />

diff --git a/src/Mapster/TypeAdapter.cs b/src/Mapster/TypeAdapter.cs
@@ -120,6 +120,10 @@ public static object Adapt(this object source, Type sourceType, Type destination
         {
             dynamic fn = config.GetMapFunction(sourceType, destinationType);
             return fn((dynamic)source);
+
+            var fn = config.GetDynamicMapFunction(sourceType, destinationType);
+            return fn(source);
+
         }
 
         /// <summary>