private static IEnumerable <IDataSource> EnumerateDataSources(DataSourceFindContext context)
{
foreach (var factory in _memberDataSourceFactories)
{
foreach (var dataSource in factory.Invoke(context))
{
if (!dataSource.IsValid)
{
continue;
}
yield return(dataSource);
if (!dataSource.IsConditional)
{
yield break;
}
++context.DataSourceIndex;
}
if (context.StopFind)
{
yield break;
}
}
}
public static IDataSourceSet CreateFor(DataSourceFindContext findContext)
{
var validDataSources = EnumerateDataSources(findContext).ToArray();
return(DataSourceSet.For(
validDataSources,
findContext,
ValueExpressionBuilders.ValueTree));
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (context.TargetMember.IsCustom)
{
yield break;
}
if (context.DoNotUseSourceMemberDataSource())
{
if (context.DataSourceIndex == 0)
{
if (context.UseFallbackComplexTypeDataSource())
{
yield return(ComplexTypeDataSource.Create(context.DataSourceIndex, context.MemberMappingData));
}
}
else if (context.UseFallbackForConditionalConfiguredDataSource())
{
yield return(context.GetFallbackDataSource());
}
if (context.UseConfiguredDataSourcesOnly())
{
yield break;
}
}
if (context.ReturnSimpleTypeToTargetDataSources())
{
var updatedMapperData = new ChildMemberMapperData(
context.MatchingSourceMemberDataSource.SourceMember,
context.TargetMember,
context.MemberMapperData.Parent);
var configuredRootDataSources = context
.MapperContext
.UserConfigurations
.GetDataSourcesForToTarget(updatedMapperData);
foreach (var configuredRootDataSource in configuredRootDataSources)
{
yield return(configuredRootDataSource);
}
}
yield return(context.MatchingSourceMemberDataSource);
if (context.UseFallbackDataSource())
{
yield return(context.GetFallbackDataSource());
}
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (TryGetMetaMemberNameParts(context, out var memberNameParts) &&
TryGetMetaMember(memberNameParts, context, out var metaMember))
{
var dataSource = metaMember.GetDataSource();
yield return(context.GetFinalDataSource(dataSource));
if (dataSource.IsConditional)
{
yield return(context.GetFallbackDataSource());
}
}
}
private static bool UseMaptimeDataSources(
DataSourceFindContext context,
out IEnumerable <IDataSource> maptimeDataSources)
{
foreach (var mapTimeDataSourceFactorySource in _mapTimeDataSourceFactorySources)
{
if (mapTimeDataSourceFactorySource.Invoke(context.MemberMapperData, out var factory))
{
maptimeDataSources = factory.Invoke(context.MemberMappingData);
return(true);
}
}
maptimeDataSources = null;
return(false);
}
private static bool UseMaptimeDataSources(
DataSourceFindContext context,
out IEnumerable <IDataSource> maptimeDataSources)
{
var applicableFactory = _mapTimeDataSourceFactories
.FirstOrDefault(context.MemberMapperData, (md, factory) => factory.IsFor(md));
if (applicableFactory == null)
{
maptimeDataSources = null;
return(false);
}
maptimeDataSources = applicableFactory.Create(context.MemberMappingData);
return(true);
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (context.ConfiguredDataSources.None())
{
yield break;
}
foreach (var dataSource in context.ConfiguredDataSources)
{
yield return(context.GetFinalDataSource(dataSource));
if (!dataSource.IsConditional)
{
yield break;
}
}
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (context.UseSourceMemberDataSource())
{
yield break;
}
var matchingSourceMember = context.BestSourceMemberMatch.SourceMember;
if (matchingSourceMember != null)
{
yield return(ConfiguredMappingDataSource.Create(
matchingSourceMember,
context.DataSourceIndex,
context.MemberMappingData));
}
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (!UseMaptimeDataSources(context, out var maptimeDataSources))
{
yield break;
}
context.StopFind = true;
foreach (var maptimeDataSource in maptimeDataSources)
{
yield return(context.GetFinalDataSource(maptimeDataSource));
if (maptimeDataSource.IsConditional)
{
continue;
}
yield break;
}
yield return(context.GetFallbackDataSource());
}
private static bool UseFallbackForConditionalConfiguredDataSource(this DataSourceFindContext context)
{
return(context.ConfiguredDataSources.Any() &&
context.ConfiguredDataSources.Last().IsConditional&&
(context.MatchingSourceMemberDataSource.SourceMember != null));
}
private static bool UseFallbackComplexTypeDataSource(this DataSourceFindContext context)
{
var targetMember = context.TargetMember;
return(targetMember.IsComplex && !targetMember.IsDictionary && (targetMember.Type != typeof(object)));
}
private static bool TryGetMetaMemberNameParts(
DataSourceFindContext context,
out IList <string> memberNameParts)
{
memberNameParts = default(IList <string>);
var targetMemberName = context.TargetMember.Name;
var previousNamePartEndIndex = targetMemberName.Length;
var currentMemberName = string.Empty;
var noMetaMemberAdded = true;
for (var i = previousNamePartEndIndex - 1; i >= 0; --i)
{
if (!char.IsUpper(targetMemberName[i]))
{
continue;
}
if (memberNameParts == null)
{
if (i == 0)
{
return(false);
}
memberNameParts = new List <string>();
}
var memberNamePart = targetMemberName.Substring(i, previousNamePartEndIndex - i);
switch (memberNamePart)
{
case HasMetaMemberPart.Name:
case FirstMetaMemberPart.Name:
case LastMetaMemberPart.Name:
case CountMetaMemberPart.Name:
if (currentMemberName.Length != 0)
{
memberNameParts.Add(GetFinalMemberName(currentMemberName, memberNamePart));
currentMemberName = string.Empty;
}
memberNameParts.Add(memberNamePart);
noMetaMemberAdded = false;
break;
default:
currentMemberName = memberNamePart + currentMemberName;
if (currentMemberName.StartsWith(NumberOfMetaMemberPart.Name, StringComparison.Ordinal))
{
currentMemberName = currentMemberName.Substring(NumberOfMetaMemberPart.Name.Length);
memberNameParts.Add(currentMemberName);
memberNameParts.Add(NumberOfMetaMemberPart.Name);
currentMemberName = string.Empty;
noMetaMemberAdded = false;
}
break;
}
previousNamePartEndIndex = i;
}
if (noMetaMemberAdded)
{
return(false);
}
if (currentMemberName.Length == 0)
{
return(memberNameParts.Any());
}
memberNameParts.Add(GetFinalMemberName(
currentMemberName,
memberNameParts[memberNameParts.Count - 1]));
return(true);
}
public static IDataSourceSet CreateFor(DataSourceFindContext findContext)
{
var validDataSources = EnumerateDataSources(findContext).ToArray();
return(DataSourceSet.For(validDataSources, findContext.MemberMapperData));
}
private static bool DoNotUseSourceMemberDataSource(this DataSourceFindContext context)
{
return(!context.BestSourceMemberMatch.IsUseable ||
context.ConfiguredDataSources.Any(context.MatchingSourceMemberDataSource, (msmds, cds) => cds.IsSameAs(msmds)));
}
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 =
(_, _, _, c) => c.MemberMappingData.Parent;
for (var i = memberNameParts.Count - 1; i >= 0; --i)
{
var memberNamePart = memberNameParts[i];
switch (memberNamePart)
{
case HasMetaMemberPart.Name:
if (HasMetaMemberPart.TryCreateFor(context.MemberMapperData, ref currentMemberPart))
{
break;
}
return(false);
case FirstMetaMemberPart.Name:
currentMemberPart = new FirstMetaMemberPart(context.MemberMapperData);
break;
case LastMetaMemberPart.Name:
currentMemberPart = new LastMetaMemberPart(context.MemberMapperData);
break;
case CountMetaMemberPart.Name:
if (CountMetaMemberPart.TryCreateFor(context.MemberMapperData, ref currentMemberPart))
{
break;
}
return(false);
case NumberOfMetaMemberPart.Name:
if (NumberOfMetaMemberPart.TryCreateFor(context.MemberMapperData, 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(memberNamePart, (mnp, m) => m.Name == mnp);
if (matchingTargetMember == null)
{
matchingTargetMember = GlobalContext.Instance
.MemberCache
.GetSourceMembers(currentMapperData.SourceType)
.FirstOrDefault(memberNamePart, (mnp, m) => m.Name == mnp);
if (matchingTargetMember == null)
{
return(false);
}
}
currentTargetMember = currentMapperData.TargetMember.Append(matchingTargetMember);
var childMemberMapperData = new ChildMemberMapperData(currentTargetMember, currentMapperData);
var memberMappingData = currentMappingData.GetChildMappingData(childMemberMapperData);
var currentSourceMemberMatch = SourceMemberMatcher.GetMatchFor(
memberMappingData,
searchParentContexts: false);
if (!currentSourceMemberMatch.IsUseable)
{
return(false);
}
currentSourceMember = currentSourceMemberMatch.SourceMember;
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)
: mappingData);
};
break;
}
if (metaMember == null)
{
metaMember = currentMemberPart;
continue;
}
if (!metaMember.TrySetNextPart(currentMemberPart))
{
return(false);
}
}
return(true);
}
private static bool UseFallbackDataSource(this DataSourceFindContext context)
{
return(!context.TargetMember.IsReadOnly &&
context.MatchingSourceMemberDataSource.IsConditional &&
(context.MatchingSourceMemberDataSource.IsValid || context.ConfiguredDataSources.Any()));
}
private static bool ReturnSimpleTypeToTargetDataSources(this DataSourceFindContext context)
{
return(context.MatchingSourceMemberDataSource.SourceMember.IsSimple &&
context.MapperContext.UserConfigurations.HasConfiguredToTargetDataSources);
}
private static bool UseConfiguredDataSourcesOnly(this DataSourceFindContext context)
{
return(context.BestSourceMemberMatch.IsUseable ||
(context.MatchingSourceMemberDataSource.SourceMember == null));
}
