public MappingPlanData GetElementMappingPlanData(MethodCallExpression mapCall)
{
var enumerableMappingData = GetMappingDataFor((ParameterExpression)mapCall.Object);
var elementMappingData = ObjectMappingDataFactory.ForElement(enumerableMappingData);
return(new MappingPlanData(elementMappingData));
}
private IObjectMappingData GetEntryMappingData(IObjectMappingData mappingData)
{
var sourceElementType = _wrappedBuilder.Context.SourceElementType;
var targetElementType = _targetDictionaryMember.GetElementType(sourceElementType);
return(ObjectMappingDataFactory.ForElement(sourceElementType, targetElementType, mappingData));
}
private IQueryable <TResultElement> PerformProjection <TResultElement>(MapperContext mapperContext)
{
var rootMappingData = ObjectMappingDataFactory.ForProjection <TSourceElement, TResultElement>(
_sourceQueryable,
mapperContext.QueryProjectionMappingContext);
var queryProjection = rootMappingData.MapStart();
return(queryProjection);
}
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 Expression GetDictionaryToElementMapping(IObjectMappingData enumerableMappingData)
{
var elementMappingData = ObjectMappingDataFactory.ForElement(
MapperData.SourceType,
_builder.Context.TargetElementType,
enumerableMappingData);
var dictionaryToElementMapping = MappingFactory.GetElementMapping(
MapperData.SourceObject,
_builder.Context.TargetElementType.ToDefaultExpression(),
elementMappingData);
return(dictionaryToElementMapping);
}
private TTarget PerformMapping <TTarget>(TTarget target)
{
if (MappingTypes <TSource, TTarget> .SkipTypesCheck)
{
// Optimise for the most common scenario:
var typedRootMappingData = ObjectMappingDataFactory
.ForRootFixedTypes(_source, target, this);
return(typedRootMappingData.MapStart());
}
var rootMappingData = ObjectMappingDataFactory.ForRoot(_source, target, this);
var result = rootMappingData.MapStart();
return((TTarget)result);
}
private IQualifiedMember GetMatchingSourceMember <TSource, TTarget>(
TSource source,
TTarget target,
Expression <Func <TTarget, object> > childMemberExpression)
{
var targetMember = TargetMemberFor(childMemberExpression);
var mappingContext = new SimpleMappingContext(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext);
var rootMappingData = ObjectMappingDataFactory.ForRoot(source, target, mappingContext);
var rootMapperData = rootMappingData.MapperData;
var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData);
var childMappingContext = rootMappingData.GetChildMappingData(childMapperData);
return(SourceMemberMatcher.GetMatchFor(childMappingContext, out _));
}
private static IObjectMappingData GetMappingDataFor(ParameterExpression mapCallSubject, IObjectMappingData mappingData)
{
if (MappingDataObjectMatches(mapCallSubject, mappingData))
{
return(mappingData);
}
return(mappingData.MapperData
.ChildMapperDatas
.Select(childMapperData => childMapperData.TargetMemberIsEnumerableElement()
? ObjectMappingDataFactory.ForElement(mappingData)
: ObjectMappingDataFactory.ForChild(
childMapperData.TargetMember.RegistrationName,
childMapperData.DataSourceIndex,
mappingData))
.Select(childMappingData => GetMappingDataFor(mapCallSubject, childMappingData))
.First(matchingMappingData => matchingMappingData != null));
}
public MappingPlanData GetChildMappingPlanData(MethodCallExpression mapCall)
{
var targetMemberName = (string)((ConstantExpression)mapCall.Arguments[2]).Value;
var dataSourceIndex = (int)((ConstantExpression)mapCall.Arguments[3]).Value;
var parentMappingData = GetMappingDataFor((ParameterExpression)mapCall.Object);
if (!parentMappingData.MapperData.Context.IsStandalone)
{
EnsureMapperCreation(parentMappingData.Mapper);
}
var childMappingData = ObjectMappingDataFactory.ForChild(
targetMemberName,
dataSourceIndex,
parentMappingData);
return(new MappingPlanData(childMappingData));
}
public IObjectMappingData ToMappingData <TSource, TTarget>()
{
if ((_mappingData != null) &&
_mappingData.MappingTypes.Equals(MappingTypes <TSource, TTarget> .Fixed))
{
return(_mappingData);
}
var ruleSet = IsForAllRuleSets
? MapperContext.RuleSets.CreateNew
: RuleSet;
var mappingContext = new SimpleMappingContext(ruleSet, MapperContext);
_mappingData = ObjectMappingDataFactory
.ForRootFixedTypes <TSource, TTarget>(mappingContext, createMapper: false);
return(_mappingData);
}
private static bool TryGetMetaMember(
IList <string> memberNameParts,
DataSourceFindContext context,
out MetaMemberPartBase metaMember)
{
var currentMappingData = default(IObjectMappingData);
var currentSourceMember = default(IQualifiedMember);
var currentTargetMember = default(QualifiedMember);
var currentMemberPart = metaMember = default(MetaMemberPartBase);
Func <IQualifiedMember, QualifiedMember, IObjectMappingData, DataSourceFindContext, IObjectMappingData> currentMappingDataFactory =
(sm, tm, md, c) => c.ChildMappingData.Parent;
for (var i = memberNameParts.Count - 1; i >= 0; --i)
{
var memberNamePart = memberNameParts[i];
switch (memberNamePart)
{
case HasMetaMemberPart.Name:
if (HasMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
case FirstMetaMemberPart.Name:
currentMemberPart = new FirstMetaMemberPart(context.MapperData);
break;
case LastMetaMemberPart.Name:
currentMemberPart = new LastMetaMemberPart(context.MapperData);
break;
case CountMetaMemberPart.Name:
if (CountMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
case NumberOfMetaMemberPart.Name:
if (NumberOfMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
default:
currentMappingData = currentMappingDataFactory.Invoke(
currentSourceMember,
currentTargetMember,
currentMappingData,
context);
var currentMapperData = currentMappingData.MapperData;
var matchingTargetMember = GlobalContext.Instance
.MemberCache
.GetTargetMembers(currentMapperData.TargetType)
.FirstOrDefault(m => m.Name == memberNamePart);
if (matchingTargetMember == null)
{
matchingTargetMember = GlobalContext.Instance
.MemberCache
.GetSourceMembers(currentMapperData.SourceType)
.FirstOrDefault(m => m.Name == memberNamePart);
if (matchingTargetMember == null)
{
return(false);
}
}
currentTargetMember = currentMapperData.TargetMember.Append(matchingTargetMember);
var childMemberMapperData = new ChildMemberMapperData(currentTargetMember, currentMapperData);
var memberMappingData = currentMappingData.GetChildMappingData(childMemberMapperData);
currentSourceMember = SourceMemberMatcher.GetMatchFor(
memberMappingData,
out _,
searchParentContexts: false);
if (currentSourceMember == null)
{
return(false);
}
currentMemberPart = new SourceMemberMetaMemberPart(
currentSourceMember,
currentMapperData,
isRootMemberPart: currentMemberPart == null);
currentMappingDataFactory = (sm, tm, md, c) =>
{
var mappingData = ObjectMappingDataFactory.ForChild(sm, tm, 0, md);
return(sm.IsEnumerable
? ObjectMappingDataFactory.ForElement(mappingData)
: ObjectMappingDataFactory.ForChild(sm, tm, 0, md));
};
break;
}
if (metaMember == null)
{
metaMember = currentMemberPart;
continue;
}
if (!metaMember.TrySetNextPart(currentMemberPart))
{
return(false);
}
}
return(true);
}
MappingPlan IProjectionPlanTargetSelector <TSource> .To <TResult>()
{
return(GetMappingPlan <TResult>(
_mapperContext.QueryProjectionMappingContext,
planContext => ObjectMappingDataFactory.ForProjection <TSource, TResult>(_exampleQueryable, planContext)));
}
public IObjectMappingData CreateRootMappingData <TDataSource, TDataTarget>(TDataSource source, TDataTarget target) => ObjectMappingDataFactory.ForRoot(source, target, this);
