public static Expression Process(Expression lambda, ObjectMapperData mapperData)
{
var targetMemberDatas = GetAllTargetMemberDatas(mapperData);
if (targetMemberDatas.None())
{
return(lambda);
}
var finder = new EnumMappingMismatchFinder(mapperData, targetMemberDatas);
finder.Visit(lambda);
var assignmentReplacements = finder._assignmentsByMismatchSet
.SelectMany(kvp => kvp.Value.Project(assignment => new
{
Assignment = assignment,
AssignmentWithWarning = (Expression)Expression.Block(kvp.Key.Warnings, assignment)
}))
.ToDictionary(d => d.Assignment, d => d.AssignmentWithWarning);
var updatedLambda = lambda.Replace(assignmentReplacements);
return(updatedLambda);
}
private static bool ObjectCouldHaveBeenMappedBefore(ObjectMapperData mapperData)
{
return(mapperData.RuleSet.Settings.AllowObjectTracking &&
mapperData.CacheMappedObjects &&
mapperData.TargetTypeHasBeenMappedBefore &&
!mapperData.SourceType.IsDictionary());
}
private static Expression GetAlreadyMappedObjectShortCircuitOrNull(ObjectMapperData mapperData)
{
if (!mapperData.RuleSet.Settings.AllowObjectTracking ||
!mapperData.CacheMappedObjects ||
mapperData.TargetTypeHasNotYetBeenMapped ||
mapperData.SourceType.IsDictionary())
{
return(null);
}
var tryGetMethod = typeof(IObjectMappingDataUntyped)
.GetPublicInstanceMethod("TryGet")
.MakeGenericMethod(mapperData.SourceType, mapperData.TargetType);
var tryGetCall = Expression.Call(
mapperData.EntryPointMapperData.MappingDataObject,
tryGetMethod,
mapperData.SourceObject,
mapperData.TargetInstance);
var ifTryGetReturn = Expression.IfThen(
tryGetCall,
Expression.Return(mapperData.ReturnLabelTarget, mapperData.TargetInstance));
return(ifTryGetReturn);
}
public bool IsFor(ObjectMapperData mapperData)
{
if (mapperData.Context.IsStandalone)
{
// A standalone context is either the root, in which case we don't
// check the dictionary for a matching object entry, or in a mapper
// completing a .Map() call, in which case we already have:
return(false);
}
if (!mapperData.SourceMemberIsStringKeyedDictionary(out var dictionarySourceMember))
{
return(false);
}
if (dictionarySourceMember.IsEntireDictionaryMatch)
{
// The dictionary has been matched to a target complex type
// member, so should only be used to get that member's member
// values, not a value for the member itself
return(false);
}
return(dictionarySourceMember.HasObjectEntries ||
!dictionarySourceMember.ValueType.IsSimple());
}
private static bool TargetIsUnmappable(ObjectMapperData mapperData)
{
if (!mapperData.TargetMember.IsComplex)
{
return(false);
}
if (mapperData.TargetType.GetPublicInstanceConstructor(Constants.EmptyTypeArray) != null)
{
return(false);
}
if (mapperData.DataSourcesByTargetMember.Any(ds => ds.Key.IsConstructorParameter() && ds.Value.HasValue))
{
return(false);
}
var configuredFactories = mapperData
.MapperContext
.UserConfigurations
.QueryObjectFactories(mapperData);
if (configuredFactories.Any())
{
return(false);
}
if (mapperData.TargetCouldBePopulated())
{
return(mapperData.DataSourcesByTargetMember.Values.Any(ds => !ds.HasValue));
}
return(true);
}
private static bool TargetIsUnconstructable(ObjectMapperData mapperData)
{
if (!mapperData.TargetMember.IsComplex ||
mapperData.TargetIsDefinitelyPopulated())
{
return(false);
}
if (mapperData.TargetType.GetPublicInstanceConstructor(Constants.EmptyTypeArray) != null)
{
return(false);
}
if (mapperData.DataSourcesByTargetMember.Any(ds => ds.Key.IsConstructorParameter() && ds.Value.HasValue))
{
return(false);
}
var configuredFactories = mapperData
.MapperContext
.UserConfigurations
.GetObjectFactories(mapperData);
return(configuredFactories.None());
}
public ChildMemberMapperData(QualifiedMember targetMember, ObjectMapperData parent)
: base(parent.SourceMember, targetMember, parent)
{
_useParentForTypeCheck = true;
Parent = parent;
Context = new MapperDataContext(this);
}
private static IEnumerable <TargetMemberData> EnumerateTargetMemberDatas(ObjectMapperData mapperData)
{
foreach (var targetMemberAndDataSource in mapperData.DataSourcesByTargetMember)
{
var targetMember = targetMemberAndDataSource.Key;
if (!TargetMemberIsAnEnum(targetMember))
{
continue;
}
var dataSources = targetMemberAndDataSource.Value
.Where(dataSource => dataSource.IsValid && IsEnum(dataSource.SourceMember.Type))
.ToArray();
if (dataSources.Any())
{
yield return(new TargetMemberData(targetMember, dataSources));
}
}
var childTargetMembersAndDataSources = mapperData
.ChildMapperDatas
.SelectMany(EnumerateTargetMemberDatas);
foreach (var childTargetMemberAndDataSources in childTargetMembersAndDataSources)
{
yield return(childTargetMemberAndDataSources);
}
}
public ChildMemberMapperData(QualifiedMember targetMember, ObjectMapperData parent)
: this(
parent.SourceMember,
targetMember,
parent)
{
}
public override IMembersSource GetMembersSource(ObjectMapperData parentMapperData)
{
return(_childMemberSource ?? (_childMemberSource =
new MemberLookupsChildMembersSource(
parentMapperData,
_targetMemberRegistrationName,
_dataSourceIndex)));
}
private EnumMappingMismatchFinder(
ObjectMapperData mapperData,
TargetMemberData[] targetMemberDatas)
{
_mapperData = mapperData;
_targetMemberDatas = targetMemberDatas;
_assignmentReplacements = new Dictionary <Expression, Expression>();
}
public static IEnumerable <ObjectMapperData> EnumerateAllMapperDatas(this ObjectMapperData mapperData)
{
yield return(mapperData);
foreach (var childMapperData in mapperData.ChildMapperDatas.SelectMany(md => md.EnumerateAllMapperDatas()))
{
yield return(childMapperData);
}
}
public MemberLookupsChildMembersSource(
ObjectMapperData parentMapperData,
string targetMemberRegistrationName,
int dataSourceIndex)
{
_parentMapperData = parentMapperData;
TargetMemberRegistrationName = targetMemberRegistrationName;
DataSourceIndex = dataSourceIndex;
}
public DictionaryToDictionaryPopulationLoopData(
DictionarySourceMember sourceMember,
ObjectMapperData mapperData)
: base(
mapperData.EnumerablePopulationBuilder,
typeof(KeyValuePair <,>).MakeGenericType(sourceMember.KeyType, sourceMember.ValueType),
mapperData.SourceObject)
{
}
private EnumMappingMismatchFinder(
ObjectMapperData mapperData,
TargetMemberData[] targetMemberDatas)
{
_mapperData = mapperData;
_targetMemberDatas = targetMemberDatas;
_assignmentsByMismatchSet =
new Dictionary <EnumMappingMismatchSet, List <Expression> >(EnumMappingMismatchSet.Comparer);
}
public static Expression GetFinalisedReturnValue(
this ObjectMapperData mapperData,
Expression value,
out bool returnsDefault)
{
returnsDefault = value.NodeType != ExpressionType.Goto;
return(returnsDefault
? mapperData.GetReturnLabel(mapperData.GetTargetFallbackValue())
: ((GotoExpression)value).Value);
}
public EnumerablePopulationBuilder(ObjectMapperData mapperData)
{
MapperData = mapperData;
Context = new EnumerablePopulationContext(mapperData);
_sourceItemsSelector = new SourceItemsSelector(this);
_sourceElementParameter = Context.SourceElementType.GetOrCreateParameter();
TargetTypeHelper = new EnumerableTypeHelper(mapperData.TargetMember);
_sourceAdapter = SourceEnumerableAdapterFactory.GetAdapterFor(this);
_populationExpressions = new List <Expression>();
}
public ChildMemberMapperData(IQualifiedMember sourceMember, QualifiedMember targetMember, ObjectMapperData parent)
: base(
parent.RuleSet,
sourceMember.Type,
targetMember.Type,
sourceMember,
targetMember,
parent)
{
Parent = parent;
Context = new MapperDataContext(this);
}
public RepeatedMapperFunc(IObjectMappingData mappingData, bool lazyLoadFuncs)
{
if (lazyLoadFuncs)
{
_mappingFuncLock = new object();
_mapperData = mappingData.MapperData;
_mapperData.IsEntryPoint = true;
return;
}
CreateMapperFunc(mappingData);
}
private static Expression GetObjectRegistrationCall(ObjectMapperData mapperData)
{
var registerMethod = typeof(IObjectMappingDataUntyped)
.GetPublicInstanceMethod(nameof(IObjectMappingDataUntyped.Register))
.MakeGenericMethod(mapperData.SourceType, mapperData.TargetType);
return(Expression.Call(
mapperData.EntryPointMapperData.MappingDataObject,
registerMethod,
mapperData.SourceObject,
mapperData.TargetInstance));
}
public static void MergeTargetMemberDataSources(
this ObjectMapperData mapperData,
QualifiedMember targetMember,
IDataSourceSet dataSources)
{
var dataSourcesByTargetMember = mapperData.DataSourcesByTargetMember;
if (dataSourcesByTargetMember.TryGetValue(targetMember, out var registeredDataSources) &&
registeredDataSources.HasValue)
{
return;
}
dataSourcesByTargetMember[targetMember] = dataSources;
}
public static ICollection <EnumMappingMismatchSet> FindMismatches(ObjectMapperData mapperData)
{
var targetMemberDatas = GetAllTargetMemberDatas(mapperData);
if (targetMemberDatas.None())
{
return(Enumerable <EnumMappingMismatchSet> .EmptyArray);
}
var mismatchSets = targetMemberDatas
.Project(d => EnumMappingMismatchSet.For(d.TargetMember, d.DataSources, mapperData))
.Filter(m => m.Any)
.ToArray();
return(mismatchSets);
}
public Expression GetMapRepeatedCallFor(
IObjectMappingData childMappingData,
MappingValues mappingValues,
ObjectMapperData declaredTypeMapperData)
{
if (ShortCircuitRecursion(childMappingData.MapperData))
{
return(GetMappingShortCircuit(childMappingData));
}
var inlineMappingBlock = MappingFactory.GetInlineMappingBlock(
childMappingData,
mappingValues,
MappingDataCreationFactory.ForChild);
return(inlineMappingBlock);
}
private static Expression GetObjectRegistrationCallOrNull(ObjectMapperData mapperData)
{
if (mapperData.TargetTypeWillNotBeMappedAgain ||
!mapperData.CacheMappedObjects ||
!mapperData.RuleSet.Settings.AllowObjectTracking)
{
return(null);
}
var registerMethod = typeof(IObjectMappingDataUntyped)
.GetPublicInstanceMethod(nameof(IObjectMappingDataUntyped.Register))
.MakeGenericMethod(mapperData.SourceType, mapperData.TargetType);
return(Expression.Call(
mapperData.EntryPointMapperData.MappingDataObject,
registerMethod,
mapperData.SourceObject,
mapperData.TargetInstance));
}
public Expression GetMapRepeatedCallFor(
IObjectMappingData mappingData,
MappingValues mappingValues,
ObjectMapperData declaredTypeMapperData)
{
var childMapperData = mappingData.MapperData;
if (WillNotMap(childMapperData))
{
return(Constants.EmptyExpression);
}
childMapperData.CacheMappedObjects = true;
childMapperData.RegisterRepeatedMapperFunc(mappingData);
var mapRepeatedCall = declaredTypeMapperData.GetMapRepeatedCall(
childMapperData.TargetMember,
mappingValues,
mappingValues.DataSourceIndex);
return(mapRepeatedCall);
}
public RootMapperMappingPlanFunction(IObjectMapper mapper)
{
_mapperData = mapper.MapperData;
_mapping = mapper.GetMappingLambda();
}
private static Expression GetReturnMappingResultExpression(ObjectMapperData mapperData, Expression mapping) => Return(mapperData.ReturnLabelTarget, mapping, mapperData.TargetType);
private bool TryGetShortCircuitFactory(ObjectMapperData mapperData, out ISourceShortCircuitFactory applicableFactory) => _shortCircuitFactories.TryFindMatch(f => f.IsFor(mapperData), out applicableFactory);
public static void Validate(ObjectMapperData mapperData)
{
VerifyMappingPlanIsComplete(GetAllMapperDatas(new[] { mapperData }));
}
public ElementMembersSource(ObjectMapperData enumerableMapperData)
{
_enumerableMapperData = enumerableMapperData;
}
