private static Expression GetSourceEnumerable(
IDataSource sourceEnumerableDataSource,
IChildMemberMappingData enumerableMappingData)
{
var mapperData = enumerableMappingData.MapperData;
var sourceElementType = sourceEnumerableDataSource.SourceMember.ElementType;
if (IsNotMappingFromLinkingType(sourceElementType, enumerableMappingData, out var forwardLink))
{
return(sourceEnumerableDataSource.Value);
}
var linkParameter = Parameters.Create(sourceElementType);
var orderedLinks = GetLinkOrdering(
sourceEnumerableDataSource.Value,
linkParameter,
forwardLink,
mapperData);
var sourceEnumerable = GetForwardLinkSelection(
orderedLinks,
linkParameter,
forwardLink,
mapperData);
return(sourceEnumerable);
}
public SourceMemberMatchContext(
IChildMemberMappingData memberMappingData,
bool searchParentContexts = true)
{
MemberMappingData = memberMappingData;
SearchParentContexts = searchParentContexts;
}
private static Expression GetValue(
IQualifiedMember sourceMember,
Expression variable,
IChildMemberMappingData childMappingData)
{
var childMapperData = childMappingData.MapperData;
if (childMapperData.TargetMember.IsSimple)
{
return(childMapperData
.MapperContext
.ValueConverters
.GetConversion(variable, childMapperData.TargetMember.Type));
}
var entrySourceMember = sourceMember.WithType(variable.Type);
var mapping = MappingFactory.GetChildMapping(
entrySourceMember,
variable,
0,
childMappingData);
return(mapping);
}
private static IEnumerable <IDataSource> GetSourceMemberDataSources(
IEnumerable <IConfiguredDataSource> configuredDataSources,
int dataSourceIndex,
IChildMemberMappingData mappingData)
{
var bestMatchingSourceMember = SourceMemberMatcher.GetMatchFor(mappingData);
var matchingSourceMemberDataSource = GetSourceMemberDataSourceOrNull(bestMatchingSourceMember, mappingData);
if ((matchingSourceMemberDataSource == null) ||
configuredDataSources.Any(cds => cds.IsSameAs(matchingSourceMemberDataSource)))
{
if (dataSourceIndex == 0)
{
if (mappingData.MapperData.TargetMember.IsComplex)
{
yield return(new ComplexTypeMappingDataSource(dataSourceIndex, mappingData));
}
}
else
{
yield return(FallbackDataSourceFor(mappingData));
}
yield break;
}
yield return(matchingSourceMemberDataSource);
if (matchingSourceMemberDataSource.IsConditional)
{
yield return(FallbackDataSourceFor(mappingData));
}
}
private static Expression GetValueParsing(
DictionarySourceMember sourceMember,
Expression variable,
IChildMemberMappingData childMappingData)
{
var childMapperData = childMappingData.MapperData;
var potentialNames = GetPotentialNames(childMapperData);
var fallbackValue = GetFallbackValue(sourceMember, variable, potentialNames, childMappingData);
if ((childMapperData.TargetMember.IsEnumerable != variable.Type.IsEnumerable()) &&
(variable.Type != typeof(object)))
{
return(fallbackValue);
}
var tryGetValueCall = GetTryGetValueCall(
variable,
potentialNames.Select(Expression.Constant),
childMapperData);
var dictionaryValueOrFallback = Expression.Condition(
tryGetValueCall,
GetValue(sourceMember, variable, childMappingData),
fallbackValue);
return(dictionaryValueOrFallback);
}
public static Expression GetChildMapping(
IQualifiedMember sourceMember,
Expression sourceMemberAccess,
int dataSourceIndex,
IChildMemberMappingData childMappingData)
{
var childMapperData = childMappingData.MapperData;
var targetMemberAccess = childMapperData.GetTargetMemberAccess();
var mappingValues = new MappingValues(
sourceMemberAccess,
targetMemberAccess,
childMapperData.EnumerableIndex);
var childObjectMappingData = ObjectMappingDataFactory.ForChild(
sourceMember,
childMapperData.TargetMember,
dataSourceIndex,
childMappingData.Parent);
if (childObjectMappingData.MapperKey.MappingTypes.RuntimeTypesNeeded)
{
return(childMapperData.Parent.GetMapCall(
mappingValues.SourceValue,
childMapperData.TargetMember,
dataSourceIndex));
}
return(GetChildMapping(
childObjectMappingData,
mappingValues,
dataSourceIndex,
childMapperData.Parent));
}
public static DataSourceSet FindFor(IChildMemberMappingData childMappingData)
{
var findContext = new DataSourceFindContext(childMappingData);
var validDataSources = EnumerateDataSources(findContext).ToArray();
return(new DataSourceSet(findContext.MapperData, validDataSources));
}
public static IMemberPopulator WithoutRegistration(
IChildMemberMappingData mappingData,
DataSourceSet dataSources,
Expression populateCondition = null)
{
return(new MemberPopulator(dataSources, populateCondition));
}
public static IQualifiedMember GetMatchFor(IChildMemberMappingData rootData)
{
var rootSourceMember = rootData.MapperData.SourceMember;
return(GetAllSourceMembers(rootSourceMember, rootData)
.FirstOrDefault(sm => IsMatchingMember(sm, rootData.MapperData)));
}
private static IQualifiedMember GetParentContextMatchOrNull(
IChildMemberMappingData targetData,
out IChildMemberMappingData contextMappingData)
{
var mappingData = targetData.Parent;
while (mappingData.Parent != null)
{
if (mappingData.MapperData.IsEntryPoint ||
mappingData.MapperData.TargetMemberIsEnumerableElement())
{
break;
}
mappingData = mappingData.Parent;
var childMapperData = new ChildMemberMapperData(targetData.MapperData.TargetMember, mappingData.MapperData);
contextMappingData = mappingData.GetChildMappingData(childMapperData);
var matchingMember = EnumerateSourceMembers(mappingData.MapperData.SourceMember, contextMappingData)
.FirstOrDefault(sm => IsMatchingMember(sm, targetData.MapperData));
if (matchingMember != null)
{
return(GetFinalSourceMember(matchingMember, targetData));
}
}
contextMappingData = null;
return(null);
}
public SourceMemberMatchContext With(IChildMemberMappingData memberMappingData)
{
MemberMappingData = memberMappingData;
_parentSourceMember = null;
MatchingSourceMember = null;
SourceMemberMatch = null;
return(this);
}
public EnumerableDataSource(
IDataSource sourceEnumerableDataSource,
int dataSourceIndex,
IChildMemberMappingData enumerableMappingData)
: base(
sourceEnumerableDataSource,
GetMapping(sourceEnumerableDataSource, dataSourceIndex, enumerableMappingData))
{
}
public ComplexTypeMappingDataSource(
IDataSource complexTypeDataSource,
int dataSourceIndex,
IChildMemberMappingData complexTypeMappingData)
: base(
complexTypeDataSource,
GetMapping(complexTypeDataSource, dataSourceIndex, complexTypeMappingData))
{
}
public DataSourceFindContext(IChildMemberMappingData childMappingData)
{
ChildMappingData = childMappingData;
ConfiguredDataSources = MapperData
.MapperContext
.UserConfigurations
.GetDataSources(MapperData);
}
public DictionaryDataSource(IChildMemberMappingData childMappingData)
: this(
new DictionarySourceMember(childMappingData.MapperData),
Expression.Variable(
childMappingData.MapperData.SourceType.GetGenericArguments().Last(),
childMappingData.MapperData.TargetMember.Name.ToCamelCase()),
childMappingData)
{
}
private static IQualifiedMember GetFinalSourceMember(
IQualifiedMember sourceMember,
IChildMemberMappingData targetData)
{
return(targetData
.MapperData
.MapperContext
.QualifiedMemberFactory
.GetFinalSourceMember(sourceMember, targetData.MapperData.TargetMember));
}
private DictionaryDataSource(
DictionarySourceMember sourceMember,
ParameterExpression variable,
IChildMemberMappingData childMappingData)
: base(
sourceMember,
new[] { variable },
GetValueParsing(sourceMember, variable, childMappingData))
{
}
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));
}
public static IMemberPopulator WithRegistration(
IChildMemberMappingData mappingData,
DataSourceSet dataSources,
Expression populateCondition)
{
var memberPopulation = WithoutRegistration(mappingData, dataSources, populateCondition);
memberPopulation.MapperData.RegisterTargetMemberDataSourcesIfRequired(dataSources);
return(memberPopulation);
}
public DataSourceFindContext With(IChildMemberMappingData memberMappingData)
{
MemberMappingData = memberMappingData;
_configuredDataSources = null;
_sourceMemberMatchContext = null;
_bestSourceMemberMatch = null;
_matchingSourceMemberDataSource = null;
DataSourceIndex = 0;
StopFind = false;
return(this);
}
public SourceMemberMatch(
IQualifiedMember sourceMember,
IChildMemberMappingData contextMappingData,
Expression condition,
bool isUseable = true)
{
SourceMember = sourceMember;
ContextMappingData = contextMappingData;
Condition = condition;
IsUseable = isUseable;
}
public EnumerableMappingDataSource(
IDataSource sourceEnumerableDataSource,
int dataSourceIndex,
IChildMemberMappingData enumerableMappingData)
: base(
sourceEnumerableDataSource.SourceMember,
sourceEnumerableDataSource.Variables,
GetMapping(sourceEnumerableDataSource, dataSourceIndex, enumerableMappingData),
sourceEnumerableDataSource.Condition)
{
}
public ComplexTypeMappingDataSource(
IDataSource complexTypeDataSource,
int dataSourceIndex,
IChildMemberMappingData complexTypeMappingData)
: base(
complexTypeDataSource.SourceMember,
complexTypeDataSource.Variables,
GetMapping(complexTypeDataSource, dataSourceIndex, complexTypeMappingData),
complexTypeDataSource.Condition)
{
}
private static Expression GetMapping(int dataSourceIndex, IChildMemberMappingData complexTypeMappingData)
{
var complexTypeMapperData = complexTypeMappingData.MapperData;
var relativeMember = complexTypeMapperData.SourceMember.RelativeTo(complexTypeMapperData.SourceMember);
var sourceMemberAccess = relativeMember.GetQualifiedAccess(complexTypeMapperData);
return(MappingFactory.GetChildMapping(
relativeMember,
sourceMemberAccess,
dataSourceIndex,
complexTypeMappingData));
}
private static bool MembersMatch(IChildMemberMappingData mappingData, Member sourceMember)
{
if (mappingData.MapperData.TargetMember.LeafMember.Equals(sourceMember))
{
return(true);
}
return(mappingData
.MapperData
.SourceMember
.Append(sourceMember)
.Matches(mappingData.MapperData.TargetMember));
}
private static Expression GetMapping(
IDataSource complexTypeDataSource,
int dataSourceIndex,
IChildMemberMappingData complexTypeMappingData)
{
var mapping = MappingFactory.GetChildMapping(
complexTypeDataSource.SourceMember,
complexTypeDataSource.Value,
dataSourceIndex,
complexTypeMappingData);
return(mapping);
}
private static Expression GetMapping(
IDataSource sourceEnumerableDataSource,
int dataSourceIndex,
IChildMemberMappingData enumerableMappingData)
{
var mapping = MappingFactory.GetChildMapping(
sourceEnumerableDataSource.SourceMember,
sourceEnumerableDataSource.Value,
dataSourceIndex,
enumerableMappingData);
return(mapping);
}
public static IDataSource Create(
IDataSource wrappedDataSource,
int dataSourceIndex,
IChildMemberMappingData complexTypeMappingData)
{
var mapping = MappingFactory.GetChildMapping(
wrappedDataSource.SourceMember,
wrappedDataSource.Value,
dataSourceIndex,
complexTypeMappingData);
return(new ComplexTypeDataSource(wrappedDataSource, mapping));
}
private IDataSource GetMaptimeDataSourceOrNull(IChildMemberMappingData childMappingData)
{
var childMapperData = childMappingData.MapperData;
if (childMapperData.TargetMember.IsComplex)
{
return(null);
}
return(_mapTimeDataSourceFactories
.FirstOrDefault(factory => factory.IsFor(childMapperData))?
.Create(childMappingData));
}
public static IDataSource Create(int dataSourceIndex, IChildMemberMappingData complexTypeMappingData)
{
var complexTypeMapperData = complexTypeMappingData.MapperData;
var relativeMember = complexTypeMapperData.SourceMember.RelativeTo(complexTypeMapperData.SourceMember);
var sourceMemberAccess = relativeMember.GetQualifiedAccess(complexTypeMapperData);
var mapping = MappingFactory.GetChildMapping(
relativeMember,
sourceMemberAccess,
dataSourceIndex,
complexTypeMappingData);
return(new ComplexTypeDataSource(complexTypeMapperData.SourceMember, mapping));
}
