public Expression GetCallbackOrNull(
CallbackPosition position,
IBasicMapperData basicData,
IMemberMapperData mapperData)
{
return(_mappingCallbackFactories?.FirstOrDefault(f => f.AppliesTo(position, basicData))?.Create(mapperData));
}
public virtual bool AppliesTo(IBasicMapperData mapperData)
{
return(RuleSetMatches(mapperData) &&
TargetMembersMatch(mapperData) &&
HasCompatibleCondition(mapperData) &&
TypesMatch(mapperData));
}
private bool HasTypeBeenMapped(Type targetType, IBasicMapperData requestingMapperData)
{
var mappedType = TargetMember.IsEnumerable ? TargetMember.ElementType : TargetType;
if (mappedType.IsAssignableFrom(targetType))
{
return(true);
}
foreach (var childMapperData in ChildMapperDatas)
{
if (childMapperData == requestingMapperData)
{
break;
}
if (childMapperData.HasTypeBeenMapped(targetType, this))
{
return(true);
}
}
if ((Parent != null) && (requestingMapperData != Parent))
{
return(Parent.HasTypeBeenMapped(targetType, this));
}
return(false);
}
public bool WillNotMap(IBasicMapperData mapperData)
{
if (!mapperData.TargetMember.IsRecursion)
{
return(false);
}
if (mapperData.SourceType.IsDictionary())
{
return(mapperData.TargetMember.Depth > 3);
}
while (mapperData != null)
{
if (mapperData.TargetMember.IsDictionary ||
mapperData.TargetType.Name.EndsWith("Dto", StringComparison.Ordinal) ||
mapperData.TargetType.Name.EndsWith("DataTransferObject", StringComparison.Ordinal))
{
return(true);
}
mapperData = mapperData.Parent;
}
return(false);
}
public virtual bool AppliesTo(IBasicMapperData mapperData)
{
return(ConfigInfo.IsFor(mapperData.RuleSet) &&
TargetMembersMatch(mapperData) &&
HasCompatibleCondition(mapperData) &&
MemberPathMatches(mapperData));
}
public static bool IsRepeatMapping(this IBasicMapperData mapperData)
{
if (mapperData.IsRoot || (mapperData.TargetMember.Depth == 2))
{
return(false);
}
if (mapperData.TargetMember.IsRecursion)
{
return(true);
}
if ((mapperData.TargetMember.Depth == 3) && mapperData.TargetMemberIsEnumerableElement())
{
return(false);
}
if (GetTargetMembers(mapperData.TargetType).All(tm => tm.IsSimple))
{
return(false);
}
// The target member we're mapping right now isn't recursive, but
// it might recurse elsewhere within the mapping graph.
// We therefore check if this member ever recurses; if so we'll
// map it by calling MapRepeated, and it'll be the entry point of
// the RepeatedMapperFunc which performs the repeated mapping:
var rootMember = mapperData.GetRootMapperData().TargetMember;
return(TargetMemberEverRecursesWithin(rootMember, mapperData.TargetMember));
}
protected bool MemberPathHasMatchingSourceAndTargetTypes(IBasicMapperData mapperData)
{
if (mapperData.HasCompatibleTypes(ConfigInfo))
{
return(true);
}
if (mapperData.IsRoot)
{
return(false);
}
var objectMapperData = (IMemberMapperData)mapperData.Parent;
while (true)
{
if (objectMapperData.HasCompatibleTypes(ConfigInfo))
{
return(true);
}
if (objectMapperData.IsEntryPoint)
{
return(false);
}
objectMapperData = objectMapperData.Parent;
}
}
protected static Expression GetMappingCallbackOrNull(
CallbackPosition callbackPosition,
IBasicMapperData basicData,
IMemberMapperData mapperData)
{
return(mapperData.MapperContext.UserConfigurations.GetCallbackOrNull(callbackPosition, basicData, mapperData));
}
public override bool AppliesTo(IBasicMapperData mapperData)
{
if (!base.AppliesTo(mapperData))
{
return(false);
}
var applicableDictionarycontext = ConfigInfo.Get <DictionaryContext>();
if (applicableDictionarycontext == All)
{
return(true);
}
while (mapperData != null)
{
if (mapperData.TargetMember.IsDictionary)
{
return(false);
}
mapperData = mapperData.Parent;
}
return(true);
}
public static bool IsRepeatMapping(this IBasicMapperData mapperData)
{
if (mapperData.IsRoot || (mapperData.TargetMember.Depth == 2))
{
return(false);
}
if (mapperData.TargetMember.IsRecursion)
{
return(true);
}
if ((mapperData.TargetMember.Depth == 3) && mapperData.TargetMemberIsEnumerableElement())
{
return(false);
}
if (TargetMemberHasRecursiveObjectGraph(mapperData.TargetMember) == false)
{
return(false);
}
// The target member we're mapping right now isn't recursive, but it has recursion
// within its child members, and its mapping might be repeated elsewhere within the
// mapping graph. We therefore check if this member ever repeats; if so we'll map it
// by calling MapRepeated, and it'll be the entry point of the RepeatedMapperFunc
// which performs the repeated mapping:
var rootMember = mapperData.GetRootMapperData().TargetMember;
return(TargetMemberEverRepeatsWithin(rootMember, mapperData.TargetMember));
}
private static IList <DerivedTypePair> GetTypePairsFor(IBasicMapperData pairTestMapperData, IMemberMapperData mapperData)
{
var derivedTypePairs = mapperData.MapperContext.UserConfigurations
.DerivedTypes
.GetDerivedTypePairsFor(pairTestMapperData, mapperData.MapperContext);
return(derivedTypePairs);
}
public static ObjectMapperData GetRootMapperData(this IBasicMapperData mapperData)
{
while (!mapperData.IsRoot)
{
mapperData = mapperData.Parent;
}
return((ObjectMapperData)mapperData);
}
private static bool ShouldUseLocalSourceValueVariable(
Expression sourceValue,
Expression mapping,
IBasicMapperData mapperData)
{
return((sourceValue.NodeType != ExpressionType.Parameter) &&
!mapperData.RuleSet.Settings.UseMemberInitialisation &&
SourceAccessCounter.MultipleAccessesExist(sourceValue, mapping));
}
public bool MapEntityKeys(IBasicMapperData basicData)
{
var applicableSetting = _entityKeyMappingSettings?
.FirstOrDefault(basicData, (bd, s) => s.AppliesTo(bd))?
.MapKeys;
return((applicableSetting == true) ||
(basicData.RuleSet.Settings.AllowEntityKeyMapping && (applicableSetting != false)));
}
protected override bool TargetMembersAreCompatible(IBasicMapperData mapperData)
{
if (base.TargetMembersAreCompatible(mapperData))
{
return(true);
}
return(TargetMember.IsRoot && TargetMember.HasCompatibleType(mapperData.TargetMember.Type));
}
public bool ShortCircuitRecursion(IBasicMapperData mapperData)
{
if (_recursionDepthSettings == null)
{
return(true);
}
return(RecursionDepthSettings.FindMatch(mapperData)?.IsBeyondDepth(mapperData) != false);
}
public override bool AppliesTo(IBasicMapperData mapperData)
{
if (mapperData.TargetMemberIsEnumerableElement())
{
return(false);
}
return(base.AppliesTo(mapperData));
}
public override bool AppliesTo(IBasicMapperData mapperData)
{
if (mapperData.TargetMember.IsDictionary)
{
return(false);
}
return(mapperData.TargetMember.Matches(TargetDictionaryEntryMember) &&
base.AppliesTo(mapperData));
}
public override bool AppliesTo(IBasicMapperData mapperData)
{
if (!base.AppliesTo(mapperData))
{
return(false);
}
return(HasNoMemberFilter ||
_memberFilter.Invoke(new TargetMemberSelector(mapperData.TargetMember)));
}
public bool DisableObjectTracking(IBasicMapperData basicData)
{
if (_trackingModeSettings.None())
{
// Object tracking switched off by default:
return(true);
}
return(_trackingModeSettings.All(tm => !tm.AppliesTo(basicData)));
}
public BasicMapperData(
MappingRuleSet ruleSet,
Type sourceType,
Type targetType,
IQualifiedMember sourceMember,
QualifiedMember targetMember,
IBasicMapperData parent)
: this(ruleSet, sourceType, targetType, targetMember, parent)
{
SourceMember = sourceMember;
}
private MapperDataContext(
ObjectMapperData mapperData,
bool isStandalone,
bool isForDerivedType,
IBasicMapperData basicMapperData)
{
_mapperData = mapperData;
IsStandalone = isStandalone;
IsForDerivedType = isForDerivedType;
UseLocalVariable = isForDerivedType || ShouldUseLocalVariable(basicMapperData);
}
private static bool UseParameterlessConstructor(
DictionarySourceMember sourceDictionaryMember,
IBasicMapperData mapperData)
{
if (sourceDictionaryMember.Type.IsInterface())
{
return(true);
}
return(sourceDictionaryMember.ValueType != mapperData.TargetMember.ElementType);
}
private static bool UseDictionaryCloneConstructor(
IQualifiedMember sourceDictionaryMember,
IBasicMapperData mapperData,
out ConstructorInfo cloneConstructor)
{
cloneConstructor = null;
return((sourceDictionaryMember.Type == mapperData.TargetType) &&
mapperData.TargetMember.ElementType.IsSimple() &&
((cloneConstructor = GetDictionaryCloneConstructor(mapperData)) != null));
}
private static bool ShortCircuitRecursion(IBasicMapperData mapperData)
{
if (!mapperData.TargetMember.IsRecursion)
{
return(false);
}
return(((IMemberMapperData)mapperData.Parent)
.MapperContext
.UserConfigurations
.ShortCircuitRecursion(mapperData));
}
public IList <DerivedTypePair> GetImplementationTypePairsFor(
IBasicMapperData mapperData,
MapperContext mapperContext)
{
if (_typePairsByTargetType.TryGetValue(mapperData.TargetType, out var typePairs))
{
return(typePairs
.Filter(tp => tp.IsImplementationPairing && tp.AppliesTo(mapperData))
.ToArray());
}
return(Enumerable <DerivedTypePair> .EmptyArray);
}
public BasicMapperData(
IQualifiedMember sourceMember,
QualifiedMember targetMember,
IBasicMapperData parent)
: this(
parent.RuleSet,
parent.SourceType,
parent.TargetType,
sourceMember,
targetMember,
parent)
{
}
protected bool MemberPathHasMatchingSourceAndTargetTypes(IBasicMapperData mapperData)
{
while (mapperData != null)
{
if (mapperData.HasCompatibleTypes(ConfigInfo))
{
return(true);
}
mapperData = mapperData.Parent;
}
return(false);
}
private static bool FallbackToCollection(IBasicMapperData mapperData)
{
if (mapperData.TargetMember.IsDictionary)
{
return(true);
}
if (!(mapperData.TargetMember is DictionaryTargetMember dictionaryTargetMember))
{
return(true);
}
return(dictionaryTargetMember.HasEnumerableEntries);
}
public BasicMapperData(
MappingRuleSet ruleSet,
Type sourceType,
Type targetType,
QualifiedMember targetMember,
IBasicMapperData parent = null)
{
IsRoot = parent == null;
_parent = parent;
SourceType = sourceType;
TargetType = targetType;
RuleSet = ruleSet;
TargetMember = targetMember ?? QualifiedMember.All;
}
