Features/data source improvements

AgileMapper/Api/Configuration/CustomDataSourceTargetMemberSpecifier.cs

@@ -7,7 +7,7 @@
     using System.Linq.Expressions;
     using System.Reflection;
     using AgileMapper.Configuration;
-    using DataSources;
+    using DataSources.Factories;
     using Extensions;
     using Extensions.Internal;
     using Members;
@@ -24,7 +24,7 @@
 #endif
 
     internal class CustomDataSourceTargetMemberSpecifier<TSource, TTarget> :
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget>,
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget>,
         ICustomProjectionDataSourceTargetMemberSpecifier<TSource, TTarget>
     {
         private readonly MappingConfigInfo _configInfo;

AgileMapper/Api/Configuration/Dictionaries/CustomDictionaryMappingTargetMemberSpecifier.cs

@@ -4,7 +4,7 @@ namespace AgileObjects.AgileMapper.Api.Configuration.Dictionaries
     using System.Linq.Expressions;
     using AgileMapper.Configuration;
     using AgileMapper.Configuration.Dictionaries;
-    using DataSources;
+    using DataSources.Factories;
 #if FEATURE_DYNAMIC
     using Dynamics;
 #endif

AgileMapper/Api/Configuration/ICustomMappingDataSourceTargetMemberSpecifier.cs → AgileMapper/Api/Configuration/ICustomDataSourceTargetMemberSpecifier.cs

@@ -8,7 +8,7 @@
     /// </summary>
     /// <typeparam name="TSource">The source type to which the configuration should apply.</typeparam>
     /// <typeparam name="TTarget">The target type to which the configuration should apply.</typeparam>
-    public interface ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget>
+    public interface ICustomDataSourceTargetMemberSpecifier<TSource, TTarget>
     {
         /// <summary>
         /// Apply the configuration to the given <paramref name="targetMember"/>.

AgileMapper/Api/Configuration/IRootMappingConfigurator.cs

@@ -127,7 +127,7 @@ ICustomDataSourceMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, T
         /// An ICustomDataSourceMappingConfigContinuation with which to control the reverse configuration, or further
         /// configure mappings from and to the source and target type being configured.
         /// </returns>
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<IMappingData<TSource, TTarget>, TSourceValue>> valueFactoryExpression);
 
         /// <summary>
@@ -138,10 +138,10 @@ ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue
         /// <typeparam name="TSourceValue">The type of the custom value being configured.</typeparam>
         /// <param name="valueFactoryExpression">The expression to map to the configured target member.</param>
         /// <returns>
-        /// An ICustomMappingDataSourceTargetMemberSpecifier with which to specify the target member to which the 
+        /// An ICustomDataSourceTargetMemberSpecifier with which to specify the target member to which the 
         /// custom value should be applied.
         /// </returns>
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<TSource, TTarget, TSourceValue>> valueFactoryExpression);
 
         /// <summary>
@@ -152,10 +152,10 @@ ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue
         /// <typeparam name="TSourceValue">The type of the custom value being configured.</typeparam>
         /// <param name="valueFactoryExpression">The expression to map to the configured target member.</param>
         /// <returns>
-        /// An ICustomMappingDataSourceTargetMemberSpecifier with which to specify the target member to which the 
+        /// An ICustomDataSourceTargetMemberSpecifier with which to specify the target member to which the 
         /// custom value should be applied.
         /// </returns>
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<TSource, TTarget, int?, TSourceValue>> valueFactoryExpression);
 
         /// <summary>
@@ -164,10 +164,10 @@ ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue
         /// <typeparam name="TSourceValue">The type of value returned by the given Func.</typeparam>
         /// <param name="valueFunc">The Func object to map to the configured target member.</param>
         /// <returns>
-        /// An ICustomMappingDataSourceTargetMemberSpecifier with which to specify the target member to which the 
+        /// An ICustomDataSourceTargetMemberSpecifier with which to specify the target member to which the 
         /// custom value should be applied.
         /// </returns>
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceValue>(
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceValue>(
             Func<TSource, TSourceValue> valueFunc);
 
         /// <summary>
@@ -177,10 +177,10 @@ ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceV
         /// <typeparam name="TSourceValue">The type of the custom constant value being configured.</typeparam>
         /// <param name="value">The constant value to map to the configured target member.</param>
         /// <returns>
-        /// An ICustomMappingDataSourceTargetMemberSpecifier with which to specify the target member to which the 
+        /// An ICustomDataSourceTargetMemberSpecifier with which to specify the target member to which the 
         /// custom constant value should be applied.
         /// </returns>
-        ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value);
+        ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value);
 
         /// <summary>
         /// Configure a constant value for the given <paramref name="targetMember"/> when mapping from and to the

AgileMapper/Api/Configuration/MappingConfigurator.cs

@@ -349,7 +349,7 @@ public ICustomDataSourceMappingConfigContinuation<TSource, TTarget> Map<TSourceV
             return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression).To(targetMember);
         }
 
-        public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        public ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<IMappingData<TSource, TTarget>, TSourceValue>> valueFactoryExpression)
         {
             return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression);
@@ -361,23 +361,23 @@ public ICustomProjectionDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TS
             return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression);
         }
 
-        public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        public ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<TSource, TTarget, TSourceValue>> valueFactoryExpression)
         {
             return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression);
         }
 
-        public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
+        public ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<TSource, TTarget, int?, TSourceValue>> valueFactoryExpression)
         {
             return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression);
         }
 
-        public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceValue>(
+        public ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceValue>(
             Func<TSource, TSourceValue> valueFunc)
             => GetConstantValueTargetMemberSpecifier(valueFunc);
 
-        public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value)
+        public ICustomDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value)
             => GetConstantValueTargetMemberSpecifier(value);
 
         public IMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, TTargetValue>(

AgileMapper/Configuration/ConfiguredIgnoredMember.cs

@@ -6,7 +6,7 @@ namespace AgileObjects.AgileMapper.Configuration
 #else
     using System.Linq.Expressions;
 #endif
-    using DataSources;
+    using DataSources.Factories;
     using Members;
     using ReadableExpressions;
 

AgileMapper/Configuration/Dictionaries/CustomDictionaryKey.cs

@@ -2,7 +2,7 @@
 {
     using System;
     using System.Dynamic;
-    using DataSources;
+    using DataSources.Factories;
     using Members;
     using ReadableExpressions.Extensions;
 #if NET35

AgileMapper/Configuration/UserConfigurationSet.cs

@@ -3,19 +3,20 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+#if NET35
+    using Microsoft.Scripting.Ast;
+#else
+    using System.Linq.Expressions;
+#endif
     using DataSources;
+    using DataSources.Factories;
     using Dictionaries;
     using Extensions;
     using Extensions.Internal;
     using Members;
     using ObjectPopulation;
     using Projection;
     using ReadableExpressions.Extensions;
-#if NET35
-    using Microsoft.Scripting.Ast;
-#else
-    using System.Linq.Expressions;
-#endif
 
     internal class UserConfigurationSet
     {

AgileMapper/DataSources/AdHocDataSource.cs

@@ -1,6 +1,5 @@
 namespace AgileObjects.AgileMapper.DataSources
 {
-    using System.Collections.Generic;
 #if NET35
     using Microsoft.Scripting.Ast;
 #else
@@ -27,8 +26,12 @@ public AdHocDataSource(
             IQualifiedMember sourceMember,
             Expression value,
             Expression condition,
-            ICollection<ParameterExpression> variables = null)
-            : base(sourceMember, variables ?? Enumerable<ParameterExpression>.EmptyArray, value, condition)
+            params ParameterExpression[] variables)
+            : base(
+                sourceMember,
+                variables,
+                value,
+                condition)
         {
         }
     }

AgileMapper/DataSources/ComplexTypeDataSource.cs

@@ -0,0 +1,65 @@
+namespace AgileObjects.AgileMapper.DataSources
+{
+#if NET35
+    using Microsoft.Scripting.Ast;
+#else
+    using System.Linq.Expressions;
+#endif
+    using Extensions.Internal;
+    using Members;
+    using ObjectPopulation;
+    using ObjectPopulation.ComplexTypes;
+
+    internal class ComplexTypeDataSource : DataSourceBase
+    {
+        private ComplexTypeDataSource(IDataSource wrappedDataSource, Expression mapping)
+            : base(wrappedDataSource, mapping)
+        {
+        }
+
+        private ComplexTypeDataSource(IQualifiedMember sourceMember, Expression mapping)
+            : base(sourceMember, mapping)
+        {
+        }
+
+        #region Factory Methods
+
+        public static IDataSource Create(IObjectMappingData mappingData)
+        {
+            var mapping = ComplexTypeMappingExpressionFactory.Instance.Create(mappingData);
+
+            return new ComplexTypeDataSource(mappingData.MapperData.SourceMember, mapping);
+        }
+
+        public static IDataSource Create(
+            IDataSource wrappedDataSource,
+            int dataSourceIndex,
+            IChildMemberMappingData complexTypeMappingData)
+        {
+            var mapping = MappingFactory.GetChildMapping(
+                wrappedDataSource.SourceMember,
+                wrappedDataSource.Value,
+                dataSourceIndex,
+                complexTypeMappingData);
+
+            return new ComplexTypeDataSource(wrappedDataSource, mapping);
+        }
+
+        public static IDataSource Create(int dataSourceIndex, IChildMemberMappingData complexTypeMappingData)
+        {
+            var complexTypeMapperData = complexTypeMappingData.MapperData;
+            var relativeMember = complexTypeMapperData.SourceMember.RelativeTo(complexTypeMapperData.SourceMember);
+            var sourceMemberAccess = relativeMember.GetQualifiedAccess(complexTypeMapperData);
+
+            var mapping = MappingFactory.GetChildMapping(
+                relativeMember,
+                sourceMemberAccess,
+                dataSourceIndex,
+                complexTypeMappingData);
+
+            return new ComplexTypeDataSource(complexTypeMapperData.SourceMember, mapping);
+        }
+
+        #endregion
+    }
+}

AgileMapper/DataSources/DataSourceBase.cs

@@ -29,7 +29,7 @@ protected DataSourceBase(IDataSource wrappedDataSource, Expression value)
 
         protected DataSourceBase(
             IQualifiedMember sourceMember,
-            ICollection<ParameterExpression> variables,
+            IList<ParameterExpression> variables,
             Expression value,
             Expression condition = null)
         {
@@ -180,26 +180,29 @@ private static bool IsNotOptionalEntityMemberId(IMemberMapperData mapperData)
         public Expression SourceMemberTypeTest { get; protected set; }
 
         public virtual bool IsValid => Value != Constants.EmptyExpression;
-
-        public virtual Expression PreCondition => null;
-
+
         public bool IsConditional => Condition != null;
 
         public virtual bool IsFallback => false;
 
         public virtual Expression Condition { get; }
 
-        public ICollection<ParameterExpression> Variables { get; }
+        public IList<ParameterExpression> Variables { get; }
 
         public Expression Value { get; }
 
-        public virtual Expression AddPreCondition(Expression population) => population;
-
-        public Expression AddCondition(Expression value, Expression alternateBranch = null)
+        public virtual Expression Finalise(Expression memberPopulation, Expression alternatePopulation)
         {
-            return alternateBranch != null
-                ? Expression.IfThenElse(Condition, value, alternateBranch)
-                : Expression.IfThen(Condition, value);
+            if (IsConditional)
+            {
+                memberPopulation = (alternatePopulation != null)
+                    ? Expression.IfThenElse(Condition, memberPopulation, alternatePopulation)
+                    : Expression.IfThen(Condition, memberPopulation);
+            }
+
+            return memberPopulation;
         }
+
+        public virtual Expression AddSourceCondition(Expression value) => value;
     }
 }