private Expression GetDictionaryPopulation(IObjectMappingData mappingData)
{
var mapperData = mappingData.MapperData;
if (mapperData.SourceMember.IsEnumerable)
{
return(GetEnumerableToDictionaryMapping(mappingData));
}
var memberPopulations = _memberPopulatorFactory
.Create(mappingData)
.Project(memberPopulation => memberPopulation.GetPopulation())
.ToArray();
if (memberPopulations.None())
{
return(null);
}
if (memberPopulations.HasOne())
{
return(memberPopulations[0]);
}
var memberPopulationBlock = Expression.Block(memberPopulations);
return(memberPopulationBlock);
}
public static Expression BuildPopulationLoop <TLoopData>(
this TLoopData loopData,
EnumerablePopulationBuilder builder,
IObjectMappingData mappingData,
Func <TLoopData, IObjectMappingData, Expression> elementPopulationFactory)
where TLoopData : IPopulationLoopData
{
// TODO: Not all enumerable mappings require the Counter
var breakLoop = Expression.Break(Expression.Label(typeof(void), "Break"));
var elementPopulation = elementPopulationFactory.Invoke(loopData, mappingData);
var loopBody = Expression.Block(
Expression.IfThen(loopData.LoopExitCheck, breakLoop),
elementPopulation,
builder.GetCounterIncrement());
var populationLoop = loopData.NeedsContinueTarget
? Expression.Loop(loopBody, breakLoop.Target, loopData.ContinueLoopTarget)
: Expression.Loop(loopBody, breakLoop.Target);
var adaptedLoop = loopData.Adapt(populationLoop);
var population = Expression.Block(
new[] { builder.Counter },
builder.Counter.AssignTo(ToNumericConverter <int> .Zero),
adaptedLoop);
return(population);
}
public ConstructionKey(IObjectMappingData mappingData)
{
MappingData = mappingData;
_ruleSet = mappingData.MappingContext.RuleSet;
_sourceMember = mappingData.MapperData.SourceMember;
_targetMember = mappingData.MapperData.TargetMember;
}
public static Expression GetChildMapping(
IObjectMappingData childMappingData,
MappingValues mappingValues,
int dataSourceIndex,
ObjectMapperData declaredTypeMapperData)
{
var childMapperData = childMappingData.MapperData;
if (childMapperData.IsRepeatMapping &&
childMapperData.RuleSet.RepeatMappingStrategy.AppliesTo(childMapperData))
{
var repeatMappingCall = childMapperData
.RuleSet
.RepeatMappingStrategy
.GetMapRepeatedCallFor(
childMappingData,
mappingValues,
dataSourceIndex,
declaredTypeMapperData);
return(repeatMappingCall);
}
var inlineMappingBlock = GetInlineMappingBlock(
childMappingData,
mappingValues,
MappingDataCreationFactory.ForChild(mappingValues, dataSourceIndex, childMapperData));
return(inlineMappingBlock);
}
private static bool SubMappingNeeded(this IObjectMappingData mappingData, out IObjectMappingData parentMappingData)
{
parentMappingData = GetParentMappingData(mappingData);
return(parentMappingData.MapperDataPopulated &&
parentMappingData.MapperData.Context.NeedsRuntimeTypedMapping);
}
private ObjectMappingData(
TSource source,
TTarget target,
int?elementIndex,
object elementKey,
MappingTypes mappingTypes,
IMappingContext mappingContext,
IObjectMappingData declaredTypeMappingData,
IObjectMappingData parent,
bool createMapper)
: base(source, target, elementIndex, elementKey, parent, mappingContext)
{
MappingTypes = mappingTypes;
MappingContext = mappingContext;
DeclaredTypeMappingData = declaredTypeMappingData;
if (parent != null)
{
Parent = parent;
return;
}
if (createMapper)
{
_mapper = MapperContext.ObjectMapperFactory.GetOrCreateRoot(this);
}
}
public Expression GetElementMapping(IObjectMappingData enumerableMappingData)
{
return(Expression.Condition(
_sourceEnumerableFound,
_enumerableLoopData.SourceElement,
_elementsDictionaryLoopData.GetElementMapping(enumerableMappingData)));
}
private void AddDerivedSourceTypePopulations(
IPopulationLoopData loopData,
QualifiedMember dictionaryEntryMember,
IObjectMappingData mappingData,
IEnumerable <Type> derivedSourceTypes,
ICollection <ParameterExpression> typedVariables,
ICollection <Expression> mappingExpressions)
{
var sourceElement = loopData.GetSourceElementValue();
var mapNextElement = Expression.Continue(loopData.ContinueLoopTarget);
var orderedDerivedSourceTypes = derivedSourceTypes
.OrderBy(t => t, TypeComparer.MostToLeastDerived);
foreach (var derivedSourceType in orderedDerivedSourceTypes)
{
var derivedSourceCheck = new DerivedSourceTypeCheck(derivedSourceType);
var typedVariableAssignment = derivedSourceCheck.GetTypedVariableAssignment(sourceElement);
typedVariables.Add(derivedSourceCheck.TypedVariable);
mappingExpressions.Add(typedVariableAssignment);
var derivedTypeMapping = GetDerivedTypeMapping(derivedSourceCheck, mappingData);
var derivedTypePopulation = GetPopulation(derivedTypeMapping, dictionaryEntryMember, mappingData);
var incrementCounter = _wrappedBuilder.GetCounterIncrement();
var derivedMappingBlock = Expression.Block(derivedTypePopulation, incrementCounter, mapNextElement);
var ifDerivedTypeReturn = Expression.IfThen(derivedSourceCheck.TypeCheck, derivedMappingBlock);
mappingExpressions.Add(ifDerivedTypeReturn);
}
}
public Expression GetTargetObjectCreation(IObjectMappingData mappingData)
{
var cachedInfos = GetTargetObjectCreationInfos(mappingData, out var constructionKey);
if (cachedInfos.None())
{
return(null);
}
constructionKey.MappingData = mappingData;
constructionKey.Infos = cachedInfos;
var cachedConstruction = _constructionsCache.GetOrAdd(constructionKey, key =>
{
var constructions = key.Infos.ProjectToArray(info => info.ToConstruction());
var construction = Construction.For(constructions, key);
key.AddSourceMemberTypeTesterIfRequired();
key.MappingData = null;
return(construction);
});
mappingData.MapperData.Context.UsesMappingDataObjectAsParameter = cachedConstruction.UsesMappingDataObjectParameter;
var constructionExpression = cachedConstruction.GetConstruction(mappingData);
return(constructionExpression);
}
public object MapRepeated(IObjectMappingData childMappingData)
{
var mapperFunc = _repeatedMappingFuncsByKey
.GetOrAdd(childMappingData.MapperKey, null);
return(mapperFunc.Map(childMappingData));
}
public ObjectMapper(
Expression <MapperFunc <TSource, TTarget> > mappingLambda,
IObjectMappingData mappingData)
{
_mapperKey = mappingData.MapperKey;
MappingLambda = mappingLambda;
MapperData = mappingData.MapperData;
if (MapperData.Context.Compile)
{
_mapperFunc = mappingLambda.Compile();
}
else if (MapperData.Context.NeedsSubMapping)
{
MapperData.Mapper = this;
}
if (MapperData.Context.NeedsSubMapping)
{
_subMappersByKey = MapperData.MapperContext.Cache.CreateNew <ObjectMapperKeyBase, IObjectMapper>();
}
if (MapperData.HasRepeatedMapperFuncs)
{
_repeatedMappingFuncsByKey = MapperData.MapperContext.Cache.CreateNew <ObjectMapperKeyBase, IRepeatedMapperFunc>();
MapperData.Mapper = this;
CacheRepeatedMappingFuncs();
}
}
private static void AddDerivedTargetTypeDataSources(
IEnumerable <Type> derivedTargetTypes,
IObjectMappingData declaredTypeMappingData,
ICollection <IDataSource> derivedTypeDataSources)
{
var declaredTypeMapperData = declaredTypeMappingData.MapperData;
if (((ICollection <Type>)derivedTargetTypes).Count > 1)
{
derivedTargetTypes = derivedTargetTypes.OrderBy(t => t, MostToLeastDerived);
}
foreach (var derivedTargetType in derivedTargetTypes)
{
var targetTypeCondition = declaredTypeMapperData.GetTargetIsDerivedTypeCheck(derivedTargetType);
var derivedTypeMapping = GetReturnMappingResultExpression(
declaredTypeMappingData,
declaredTypeMapperData.SourceObject,
derivedTargetType,
out var derivedTypeMappingData);
if (derivedTypeMapping == EmptyExpression)
{
continue;
}
var derivedTargetTypeDataSource = new DerivedComplexTypeDataSource(
derivedTypeMappingData.MapperData.SourceMember,
targetTypeCondition,
derivedTypeMapping);
derivedTypeDataSources.Add(derivedTargetTypeDataSource);
}
}
public static Expression GetDerivedTypeMapping(
IObjectMappingData declaredTypeMappingData,
Expression sourceValue,
Type targetType,
out IObjectMappingData derivedTypeMappingData)
{
derivedTypeMappingData = declaredTypeMappingData.WithTypes(sourceValue.Type, targetType);
var declaredTypeMapperData = declaredTypeMappingData.MapperData;
if (DerivedSourceTypeIsUnconditionallyIgnored(derivedTypeMappingData))
{
return(declaredTypeMapperData.TargetObject.GetConversionTo(targetType));
}
var targetValue = declaredTypeMapperData.TargetMember.IsReadable
? declaredTypeMapperData.TargetObject.GetConversionTo(targetType)
: targetType.ToDefaultExpression();
if (declaredTypeMappingData.IsRoot)
{
return(GetDerivedTypeRootMapping(derivedTypeMappingData, sourceValue, targetValue));
}
if (declaredTypeMapperData.TargetMemberIsEnumerableElement())
{
return(MappingFactory.GetElementMapping(derivedTypeMappingData, sourceValue, targetValue));
}
return(GetDerivedTypeChildMapping(derivedTypeMappingData, sourceValue, targetValue));
}
protected override Expression GetNewObjectCreation(IObjectMappingData mappingData, IList <Expression> memberPopulations)
{
var objectCreation = base.GetNewObjectCreation(mappingData, memberPopulations);
if (objectCreation == null)
{
memberPopulations.Clear();
}
if (memberPopulations.None())
{
return(objectCreation);
}
var memberBindings = GetMemberBindingsFrom(memberPopulations);
if (memberBindings.None())
{
return(objectCreation);
}
var objectNewings = NewExpressionFinder.FindIn(objectCreation);
var newingReplacements = new Dictionary <Expression, Expression>(objectNewings.Count);
foreach (var objectNewing in objectNewings)
{
var objectInit = Expression.MemberInit(objectNewing, memberBindings);
newingReplacements.Add(objectNewing, objectInit);
}
var fullObjectInit = objectCreation.Replace(newingReplacements);
return(fullObjectInit);
}
public Expression GetPopulation(
EnumerablePopulationBuilder builder,
IObjectMappingData enumerableMappingData)
{
if (builder.ElementTypesAreSimple)
{
builder.AssignSourceVariableFrom(s => s.SourceItemsProjectedToTargetType().ExcludingTargetItems());
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
if (builder.ElementsAreIdentifiable)
{
builder.CreateCollectionData();
builder.MapIntersection(enumerableMappingData);
builder.AssignSourceVariableFrom(s => s.CollectionDataNewSourceItems());
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
builder.AssignSourceVariableFromSourceObject();
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
private IList <IConstructionInfo> GetTargetObjectCreationInfos(
IObjectMappingData mappingData,
out ConstructionKey constructionKey)
{
return(_constructionInfosCache.GetOrAdd(constructionKey = new ConstructionKey(mappingData), key =>
{
IList <IConstructionInfo> constructionInfos = new List <IConstructionInfo>();
AddConfiguredConstructionInfos(
constructionInfos,
key,
out var otherConstructionRequired);
if (otherConstructionRequired && !key.MappingData.MapperData.TargetType.IsAbstract())
{
AddAutoConstructionInfos(constructionInfos, key);
}
key.AddSourceMemberTypeTesterIfRequired();
key.MappingData = null;
return constructionInfos.None()
? Enumerable <IConstructionInfo> .EmptyArray
: constructionInfos;
}));
}
protected override IEnumerable <Expression> GetShortCircuitReturns(IObjectMappingData mappingData)
{
var mapperData = mappingData.MapperData;
if (SourceObjectCouldBeNull(mapperData))
{
var returnNull = Expression.Return(
mapperData.ReturnLabelTarget,
mapperData.TargetType.ToDefaultExpression());
yield return(Expression.IfThen(mapperData.SourceObject.GetIsDefaultComparison(), returnNull));
}
var alreadyMappedShortCircuit = GetAlreadyMappedObjectShortCircuitOrNull(mapperData);
if (alreadyMappedShortCircuit != null)
{
yield return(alreadyMappedShortCircuit);
}
if (TryGetShortCircuitFactory(mapperData, out var sourceShortCircuitFactory))
{
yield return(sourceShortCircuitFactory.GetShortCircuit(mappingData));
}
}
public static Expression GetInlineMappingBlock(
IObjectMappingData mappingData,
MappingValues mappingValues,
Expression createMappingDataCall)
{
var mapper = mappingData.GetOrCreateMapper();
if (mapper == null)
{
if (mappingData.HasSameTypedConfiguredDataSource())
{
// Configured data source for an otherwise-unconstructable complex type:
return(mappingValues.SourceValue);
}
return(Constants.EmptyExpression);
}
var mapperData = mapper.MapperData;
if (mapperData.Context.UsesMappingDataObject)
{
return(UseLocalValueVariable(
mapperData.MappingDataObject,
createMappingDataCall,
mapper.MappingExpression,
mapperData));
}
return(GetDirectAccessMapping(
mapper.MappingLambda.Body,
mapperData,
mappingValues,
createMappingDataCall));
}
protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
{
if (mappingData.MapperData.TargetCouldBePopulated())
{
// If a target complex type is readonly or unconstructable
// we still try to map to it using an existing non-null value:
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
if (mappingData.MapperData.MapperContext.ConstructionFactory.GetNewObjectCreation(mappingData) != null)
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
var targetType = mappingData.MapperData.TargetType;
if (targetType.IsAbstract() && mappingData.MapperData.GetDerivedTargetTypes().Any())
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
nullMappingBlock = Expression.Block(
ReadableExpression.Comment("Cannot construct an instance of " + targetType.GetFriendlyName()),
targetType.ToDefaultExpression());
return(true);
}
private static IMemberPopulation Create(Member targetMember, IObjectMappingData mappingData)
{
var qualifiedMember = mappingData.MapperData.TargetMember.Append(targetMember);
var childMapperData = new ChildMemberMapperData(qualifiedMember, mappingData.MapperData);
Expression populateCondition;
if (TargetMemberIsUnconditionallyIgnored(childMapperData, out populateCondition))
{
return(MemberPopulation.IgnoredMember(childMapperData));
}
var childMappingData = mappingData.GetChildMappingData(childMapperData);
var dataSources = childMapperData
.MapperContext
.DataSources
.FindFor(childMappingData);
if (dataSources.None)
{
return(MemberPopulation.NoDataSource(childMapperData));
}
return(new MemberPopulation(childMapperData, dataSources, populateCondition));
}
private static Expression GetParameterlessDictionaryAssignment(IObjectMappingData mappingData)
{
var helper = mappingData.MapperData.EnumerablePopulationBuilder.TargetTypeHelper;
var newDictionary = helper.GetEmptyInstanceCreation();
return(GetDictionaryAssignment(newDictionary, mappingData));
}
public override bool IsFor(IObjectMappingData mappingData)
{
var mapperData = mappingData.MapperData;
return(mapperData.IsRoot &&
mapperData.TargetMember.IsEnumerable &&
mapperData.SourceType.IsQueryable());
}
private static Expression GetFallbackValue(IObjectMappingData mappingData)
{
return(mappingData.MappingContext
.RuleSet
.FallbackDataSourceFactory
.Create(mappingData.MapperData)
.Value);
}
public static IList <IBasicConstructionInfo> GetTargetObjectCreationInfos(this IObjectMappingData mappingData)
{
return(mappingData
.MapperData
.MapperContext
.ConstructionFactory
.GetTargetObjectCreationInfos(mappingData));
}
public override IMembersSource GetMembersSource(IObjectMappingData parentMappingData)
{
return(_childMemberSource ?? (_childMemberSource =
new MemberLookupsChildMembersSource(
parentMappingData,
_targetMemberRegistrationName,
_dataSourceIndex)));
}
public IDataSource CreateFor(IObjectMappingData mappingData)
{
var mappingExpression = _mappingExpressionFactory.Create(mappingData);
return(new AdHocDataSource(
mappingData.MapperData.SourceMember,
mappingExpression));
}
private Expression AssignDictionaryEntry(IPopulationLoopData loopData, IObjectMappingData mappingData)
{
loopData.NeedsContinueTarget = true;
var dictionaryEntryMember = _targetDictionaryMember.GetElementMember();
return(AssignDictionaryEntry(loopData, dictionaryEntryMember, mappingData));
}
public static Expression GetTargetObjectCreation(this IObjectMappingData mappingData)
{
return(mappingData
.MapperData
.MapperContext
.ConstructionFactory
.GetNewObjectCreation(mappingData));
}
public static Expression Create(EnumerablePopulationBuilder builder, IObjectMappingData enumerableMappingData)
{
builder.AssignSourceVariableFromSourceObject();
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
public Expression GetPopulation(
EnumerablePopulationBuilder builder,
IObjectMappingData enumerableMappingData)
{
builder.PopulateTargetVariableFromSourceObjectOnly(enumerableMappingData);
return(builder);
}
