public IEnumerable <Expression> GetPopulation(MappingCreationContext context)
{
var mappingData = context.MappingData;
var mapperData = context.MapperData;
GetCreationCallbacks(context, out var preCreationCallback, out var postCreationCallback);
var populationsAndCallbacks = GetPopulationsAndCallbacks(mappingData).ToList();
if (context.InstantiateLocalVariable && mapperData.Context.UseLocalVariable)
{
yield return(preCreationCallback);
var assignCreatedObject = postCreationCallback != null;
yield return(GetLocalVariableInstantiation(assignCreatedObject, populationsAndCallbacks, mappingData));
yield return(postCreationCallback);
}
yield return(GetObjectRegistrationCallOrNull(mapperData));
foreach (var population in populationsAndCallbacks)
{
yield return(population);
}
mappingData.MapperKey.AddSourceMemberTypeTesterIfRequired(mappingData);
}
public static Expression GetMappingOrNull(
MappingCreationContext context,
out bool isConditional)
{
var mappingData = context.MappingData;
var derivedTypeDataSources = DerivedComplexTypeDataSourcesFactory.CreateFor(mappingData);
if (derivedTypeDataSources.None())
{
isConditional = false;
return(null);
}
var derivedTypeDataSourceSet = DataSourceSet.For(
derivedTypeDataSources,
mappingData,
ValueExpressionBuilders.ValueSequence);
isConditional =
derivedTypeDataSources.Last().IsConditional&&
!mappingData.MapperData.TargetType.IsAbstract();
if (!isConditional)
{
context.MappingComplete = true;
}
return(derivedTypeDataSourceSet.BuildValue());
}
protected override IEnumerable <Expression> GetObjectPopulation(MappingCreationContext context)
{
var expressionFactory = context.MapperData.UseMemberInitialisations()
? _memberInitPopulationFactory
: _multiStatementPopulationFactory;
return(expressionFactory.GetPopulation(context));
}
protected override void AddObjectPopulation(MappingCreationContext context)
{
var expressionFactory = context.MapperData.UseMemberInitialisations()
? _memberInitPopulationFactory
: _multiStatementPopulationFactory;
expressionFactory.AddPopulation(context);
}
public void AddPopulation(MappingCreationContext context)
{
var mappingData = context.MappingData;
var mapperData = mappingData.MapperData;
GetCreationCallbacks(context, out var preCreationCallback, out var postCreationCallback);
var populationsAndCallbacks = GetPopulationsAndCallbacks(mappingData).ToList();
var guardPopulations = false;
if (context.InstantiateLocalVariable && mapperData.Context.UseLocalVariable)
{
context.MappingExpressions.AddUnlessNullOrEmpty(preCreationCallback);
var hasPostCreationCallback = postCreationCallback != null;
var assignCreatedObject = hasPostCreationCallback;
var localVariableInstantiation = GetLocalVariableInstantiation(
assignCreatedObject,
populationsAndCallbacks,
mappingData);
context.MappingExpressions.Add(localVariableInstantiation);
guardPopulations = LocalVariableCouldBeNull(localVariableInstantiation);
if (hasPostCreationCallback)
{
context.MappingExpressions.Add(postCreationCallback);
}
}
if (IncludeObjectRegistration(mapperData))
{
context.MappingExpressions.Add(GetObjectRegistrationCall(mapperData));
}
if (populationsAndCallbacks.None())
{
goto AddTypeTester;
}
if (guardPopulations)
{
context.MappingExpressions.Add(Expression.IfThen(
mappingData.MapperData.LocalVariable.GetIsNotDefaultComparison(),
Expression.Block(populationsAndCallbacks)));
goto AddTypeTester;
}
context.MappingExpressions.AddRange(populationsAndCallbacks);
AddTypeTester:
mappingData.MapperKey.AddSourceMemberTypeTesterIfRequired(mappingData);
}
public static IDataSource Create(
IQualifiedMember sourceMember,
int dataSourceIndex,
IChildMemberMappingData childMappingData)
{
var childMapperData = childMappingData.MapperData;
if (!childMapperData.MapperContext.UserConfigurations.HasMappingFactories)
{
return(new NullDataSource(Constants.EmptyExpression));
}
var childObjectMappingData = ObjectMappingDataFactory.ForChild(
sourceMember,
childMapperData.TargetMember,
dataSourceIndex,
childMappingData.Parent);
var childCreationContext = new MappingCreationContext(childObjectMappingData);
var mapping = ConfiguredMappingFactory
.GetMappingOrNull(childCreationContext, out _);
if (mapping == null)
{
return(new NullDataSource(Constants.EmptyExpression));
}
var childObjectMapperData = childObjectMappingData.MapperData;
var sourceMemberAccess = sourceMember.GetRelativeQualifiedAccess(childMapperData);
var targetMemberAccess = childMapperData.GetTargetMemberAccess();
var mappingValues = new MappingValues(
sourceMemberAccess,
targetMemberAccess,
childMapperData.ElementIndex,
childMapperData.ElementKey,
dataSourceIndex);
var directAccessMapping = MappingFactory.GetDirectAccessMapping(
mapping,
childObjectMapperData,
mappingValues,
MappingDataCreationFactory.ForChild(mappingValues, childObjectMapperData));
var returnValue = childObjectMapperData
.GetFinalisedReturnValue(directAccessMapping, out var returnsDefault);
if (returnsDefault)
{
returnValue = Expression.Block(directAccessMapping, returnValue);
}
return(new AdHocDataSource(sourceMember, returnValue, childMapperData));
}
private static void GetCreationCallbacks(
MappingCreationContext context,
out Expression preCreationCallback,
out Expression postCreationCallback)
{
if (context.RuleSet.Settings.UseSingleRootMappingExpression ||
!context.InstantiateLocalVariable ||
context.MapperData.TargetIsDefinitelyPopulated())
{
preCreationCallback = postCreationCallback = null;
return;
}
preCreationCallback = GetCreationCallbackOrNull(Before, context.MapperData);
postCreationCallback = GetCreationCallbackOrNull(After, context.MapperData);
}
protected override IEnumerable <Expression> GetObjectPopulation(MappingCreationContext context)
{
var mapperData = context.MapperData;
var queryProjection = mapperData
.EnumerablePopulationBuilder
.GetSourceItemsProjection(
mapperData.SourceObject,
sourceParameter => MappingFactory.GetElementMapping(
sourceParameter,
mapperData.TargetMember.ElementType.ToDefaultExpression(),
context.MappingData));
queryProjection = QueryProjectionModifier.Modify(queryProjection, context.MappingData);
yield return(queryProjection);
}
protected override IEnumerable <Expression> GetObjectPopulation(MappingCreationContext context)
{
if (!context.MapperData.SourceMember.IsEnumerable)
{
yield break;
}
var elementMapperData = context.MapperData.GetElementMapperData();
if (elementMapperData.IsRepeatMapping() &&
context.RuleSet.RepeatMappingStrategy.WillNotMap(elementMapperData))
{
yield break;
}
yield return(context.RuleSet.EnumerablePopulationStrategy.GetPopulation(
context.MapperData.EnumerablePopulationBuilder,
context.MappingData));
}
protected override bool ShortCircuitMapping(MappingCreationContext context, out Expression mapping)
{
var derivedTypeDataSources = DerivedComplexTypeDataSourcesFactory.CreateFor(context.MappingData);
if (derivedTypeDataSources.None())
{
return(base.ShortCircuitMapping(context, out mapping));
}
var derivedTypeDataSourceSet = DataSourceSet.For(
derivedTypeDataSources,
context.MapperData,
ValueExpressionBuilders.ValueSequence);
mapping = derivedTypeDataSourceSet.BuildValue();
if (derivedTypeDataSources.Last().IsConditional)
{
context.MappingExpressions.Add(mapping);
return(false);
}
var shortCircuitReturns = GetShortCircuitReturns(context.MappingData).ToArray();
if (shortCircuitReturns.Any())
{
context.MappingExpressions.AddRange(shortCircuitReturns);
}
if (mapping.NodeType == ExpressionType.Goto)
{
mapping = ((GotoExpression)mapping).Value;
context.MappingExpressions.Add(context.MapperData.GetReturnLabel(mapping));
}
else
{
context.MappingExpressions.Add(mapping);
context.MappingExpressions.Add(context.MapperData.GetReturnLabel(mapping.Type.ToDefaultExpression()));
}
mapping = Expression.Block(context.MappingExpressions);
return(true);
}
protected override void AddObjectPopulation(MappingCreationContext context)
{
if (!HasCompatibleSourceMember(context.MapperData))
{
return;
}
var elementContext = context.MapperData.GetElementMemberContext();
if (elementContext.IsRepeatMapping() &&
context.RuleSet.RepeatMappingStrategy.WillNotMap(elementContext))
{
return;
}
var population = context.RuleSet.EnumerablePopulationStrategy.Invoke(
context.MapperData.EnumerablePopulationBuilder,
context.MappingData);
context.MappingExpressions.Add(population);
}
