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 = GetLoopBody(loopData, builder, breakLoop, elementPopulation);
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);
}
private static BlockExpression GetLoopBody(
IPopulationLoopData loopData,
EnumerablePopulationBuilder builder,
Expression breakLoop,
Expression elementPopulation)
{
var ifExitCheckBreakLoop = Expression.IfThen(loopData.LoopExitCheck, breakLoop);
var counterIncrement = builder.GetCounterIncrement();
if (elementPopulation.NodeType != ExpressionType.Block)
{
return(Expression.Block(ifExitCheckBreakLoop, elementPopulation, counterIncrement));
}
var elementPopulationBlock = (BlockExpression)elementPopulation;
var loopExpressions = new Expression[elementPopulationBlock.Expressions.Count + 2];
loopExpressions[0] = ifExitCheckBreakLoop;
loopExpressions.CopyFrom(elementPopulationBlock.Expressions, startIndex: 1);
loopExpressions[loopExpressions.Length - 1] = counterIncrement;
return(elementPopulationBlock.Variables.Any()
? Expression.Block(elementPopulationBlock.Variables, loopExpressions)
: Expression.Block(loopExpressions));
}
private static Expression ApplySourceFilterIfAppropriate(
Expression elementPopulation,
IPopulationLoopData loopData,
EnumerablePopulationBuilder builder)
{
if (!builder.MapperData.MapperContext.UserConfigurations.HasSourceValueFilters)
{
return(elementPopulation);
}
var sourceElement = loopData.GetSourceElementValue();
var sourceValueFilters = builder.MapperData
.GetSourceValueFilters(sourceElement.Type);
if (sourceValueFilters.None())
{
return(elementPopulation);
}
var sourceFilterConditions = sourceValueFilters
.GetFilterConditionsOrNull(sourceElement, builder.MapperData);
return((sourceFilterConditions != null)
? Expression.IfThen(sourceFilterConditions, elementPopulation)
: elementPopulation);
}
public static Expression Create(
EnumerablePopulationBuilder builder,
IObjectMappingData enumerableMappingData)
{
if (builder.TargetElementsAreSimple)
{
builder.AssignSourceVariableTo(s => s.SourceItemsProjectedToTargetType().ExcludingTargetItems());
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
if (builder.ElementsAreIdentifiable)
{
builder.CreateCollectionData();
builder.MapIntersection(enumerableMappingData);
builder.AssignSourceVariableTo(s => s.CollectionDataNewSourceItems());
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
builder.AssignSourceVariableToSourceObject();
builder.AssignTargetVariable();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
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);
}
public EnumerableSourcePopulationLoopData(
EnumerablePopulationBuilder builder,
Type elementType,
Expression enumerableSubject)
{
Builder = builder;
_enumerableSubject = enumerableSubject;
_getEnumeratorMethod = typeof(IEnumerable <>).MakeGenericType(elementType).GetPublicInstanceMethod("GetEnumerator");
_enumerator = Expression.Variable(_getEnumeratorMethod.ReturnType, "enumerator");
ContinueLoopTarget = Expression.Label(typeof(void), "Continue");
LoopExitCheck = Expression.Not(Expression.Call(_enumerator, typeof(IEnumerator).GetPublicInstanceMethod("MoveNext")));
SourceElement = Expression.Property(_enumerator, "Current");
}
public IndexedSourcePopulationLoopData(EnumerablePopulationBuilder builder)
{
_builder = builder;
ContinueLoopTarget = Expression.Label(typeof(void), "Continue");
LoopExitCheck = Expression.Equal(builder.Counter, builder.GetSourceCountAccess());
_indexedSourceAccess = builder.GetSourceIndexAccess();
_useDirectValueAccess =
builder.ElementTypesAreSimple ||
builder.SourceTypeHelper.ElementType.RuntimeTypeNeeded() ||
builder.TargetTypeHelper.ElementType.RuntimeTypeNeeded();
_sourceElement = _useDirectValueAccess
? _indexedSourceAccess
: builder.Context.GetSourceParameterFor(builder.SourceTypeHelper.ElementType);
}
public Expression GetPopulation(
EnumerablePopulationBuilder builder,
IObjectMappingData enumerableMappingData)
{
if (builder.ElementTypesAreSimple)
{
if (builder.TargetTypeHelper.IsReadOnly)
{
builder.PopulateTargetVariableFromSourceObjectOnly();
return(builder);
}
builder.AssignSourceVariableFrom(s => s.SourceItemsProjectedToTargetType());
builder.AssignTargetVariable();
builder.RemoveAllTargetItems();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
if (builder.ElementsAreIdentifiable)
{
builder.CreateCollectionData();
builder.MapIntersection(enumerableMappingData);
builder.AssignSourceVariableFrom(s => s.CollectionDataNewSourceItems());
builder.AssignTargetVariable();
builder.RemoveTargetItemsById();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
builder.AssignSourceVariableFromSourceObject();
builder.AssignTargetVariable();
builder.RemoveAllTargetItems();
builder.AddNewItemsToTargetVariable(enumerableMappingData);
return(builder);
}
public static ISourceEnumerableAdapter GetAdapterFor(EnumerablePopulationBuilder builder)
{
var dictionarySourceMember = builder.MapperData.GetDictionarySourceMemberOrNull();
if (dictionarySourceMember != null)
{
if (!builder.MapperData.IsRoot)
{
if (dictionarySourceMember.HasObjectEntries)
{
return(new SourceObjectDictionaryAdapter(dictionarySourceMember, builder));
}
if (dictionarySourceMember.CouldContainSourceInstance)
{
return(new SourceInstanceDictionaryAdapter(dictionarySourceMember, builder));
}
}
return(new SourceElementsDictionaryAdapter(dictionarySourceMember, builder));
}
return(new DefaultSourceEnumerableAdapter(builder));
}
protected SourceEnumerableAdapterBase(EnumerablePopulationBuilder builder)
{
Builder = builder;
}
public DefaultSourceEnumerableAdapter(EnumerablePopulationBuilder builder)
: base(builder)
{
}
public EnumerableSourcePopulationLoopData(EnumerablePopulationBuilder builder)
: this(builder, builder.SourceTypeHelper.ElementType, builder.SourceValue)
{
}
