public ConfiguredDataSource(
IQualifiedMember sourceMember,
Expression configuredCondition,
Expression convertedValue,
bool isSequential,
bool hasMatcher,
IMemberMapperData mapperData)
: base(sourceMember, convertedValue, mapperData)
{
_originalValue = convertedValue;
IsSequential = isSequential;
HasConfiguredMatcher = hasMatcher;
if (configuredCondition == null)
{
Condition = base.Condition;
return;
}
HasConfiguredCondition = true;
Condition = (base.Condition != null)
? Expression.AndAlso(base.Condition, configuredCondition)
: configuredCondition;
}
public SourceMemberDataSource(IQualifiedMember sourceMember, IMemberMapperData mapperData)
: this(
sourceMember,
sourceMember.GetQualifiedAccess(mapperData.SourceObject).GetConversionTo(sourceMember.Type),
mapperData)
{
}
public static string GetFriendlyMemberPath(
this IQualifiedMember member,
string rootTypeName,
string rootMemberName)
{
var memberPath = member.GetPath();
if (memberPath == rootMemberName)
{
return(rootTypeName);
}
if (memberPath.StartsWith(rootMemberName, Ordinal))
{
return(rootTypeName + memberPath.Substring(rootMemberName.Length));
}
var rootMemberNameIndex = memberPath.IndexOf("." + rootMemberName + ".", Ordinal);
if (rootMemberNameIndex == -1)
{
return(rootTypeName + memberPath);
}
var rootMemberString = memberPath.Substring(rootMemberNameIndex + rootMemberName.Length + 2);
var path = rootTypeName + "." + rootMemberString;
return(path);
}
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 ConstructionKey(IObjectMappingData mappingData)
{
MappingData = mappingData;
_ruleSet = mappingData.MappingContext.RuleSet;
_sourceMember = mappingData.MapperData.SourceMember;
_targetMember = mappingData.MapperData.TargetMember;
}
public DerivedComplexTypeDataSource(
IQualifiedMember sourceMember,
Expression condition,
Expression value)
: base(sourceMember, Constants.EmptyParameters, value, condition)
{
}
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);
}
public DerivedComplexTypeDataSource(
IQualifiedMember sourceMember,
Expression condition,
Expression value)
: base(sourceMember, Enumerable <ParameterExpression> .EmptyArray, value, condition)
{
}
private ConfiguredDataSource(
IQualifiedMember sourceMember,
Expression configuredCondition,
Expression convertedValue,
IMemberMapperData mapperData)
: base(sourceMember, convertedValue, mapperData)
{
_originalValueString = convertedValue.ToString();
Expression condition;
if (configuredCondition != null)
{
condition = (base.Condition != null)
? Expression.AndAlso(base.Condition, configuredCondition)
: configuredCondition;
}
else
{
condition = base.Condition;
}
if (condition == null)
{
return;
}
Condition = condition;
_conditionString = condition.ToString();
}
public DictionarySourceMember(IMemberMapperData mapperData)
{
_wrappedSourceMember = mapperData.SourceMember;
_targetMember = mapperData.TargetMember;
Type = mapperData.SourceType;
EntryType = Type.GetGenericArguments()[1];
}
private static string GetMemberPath(IQualifiedMember member, IQualifiedMember rootMember)
{
var rootTypeName = rootMember.Type.GetFriendlyName();
var memberPath = member.GetPath();
if (memberPath == rootMember.Name)
{
return(rootTypeName);
}
if (memberPath.StartsWith(rootMember.Name, StringComparison.Ordinal))
{
return(rootTypeName + memberPath.Substring(rootMember.Name.Length));
}
var rootMemberNameIndex = memberPath.IndexOf("." + rootMember.Name + ".", StringComparison.Ordinal);
if (rootMemberNameIndex == -1)
{
return(rootTypeName + memberPath);
}
var rootMemberString = memberPath.Substring(rootMemberNameIndex + rootMember.Name.Length + 2);
var path = rootTypeName + "." + rootMemberString;
return(path);
}
private DictionarySourceMember(
Type dictionaryType,
IQualifiedMember wrappedSourceMember,
QualifiedMember matchedTargetMember,
bool isEntireDictionaryMatch,
Type keyType = null,
Type valueType = null)
{
_wrappedSourceMember = wrappedSourceMember;
_matchedTargetMember = matchedTargetMember;
IsEntireDictionaryMatch = isEntireDictionaryMatch;
Type = dictionaryType;
if (keyType == null)
{
var dictionaryTypes = Type.GetDictionaryTypes();
KeyType = dictionaryTypes.Key;
ValueType = dictionaryTypes.Value;
}
else
{
KeyType = keyType;
ValueType = valueType;
}
EntryMember = (wrappedSourceMember as DictionaryEntrySourceMember) ??
new DictionaryEntrySourceMember(ValueType, matchedTargetMember, this);
HasObjectEntries = ValueType == typeof(object);
CouldContainSourceInstance =
HasObjectEntries || (matchedTargetMember.IsEnumerable == ValueType.IsEnumerable());
}
private string GetSourceMemberDescription(IQualifiedMember sourceMember)
{
var rootSourceMember = MapperContext.QualifiedMemberFactory.RootSource <TSource, TTarget>();
var sourceMemberPath = sourceMember.GetFriendlyMemberPath(rootSourceMember);
return(sourceMemberPath + " " + GetTypeDescription(sourceMember.Type));
}
public AdHocDataSource(
IQualifiedMember sourceMember,
Expression value,
IMemberMapperData mapperData)
: base(sourceMember, value, mapperData)
{
}
public IQualifiedMember RelativeTo(IQualifiedMember otherMember)
{
if (!(otherMember is ConfiguredSourceMember otherConfiguredMember))
{
return(this);
}
var relativeMemberChain = _childMembers.RelativeTo(otherConfiguredMember._childMembers);
if ((relativeMemberChain == _childMembers) ||
relativeMemberChain.SequenceEqual(_childMembers))
{
return(this);
}
return(new ConfiguredSourceMember(
_rootValue,
Type,
IsEnumerable,
IsSimple,
Name,
_matchedTargetMemberJoinedNames,
_mapperContext,
relativeMemberChain));
}
public AdHocDataSource(
IQualifiedMember sourceMember,
Expression value,
Expression condition,
ICollection <ParameterExpression> variables = null)
: base(sourceMember, variables ?? Enumerable <ParameterExpression> .EmptyArray, value, condition)
{
}
public SourceMemberMatchContext With(IChildMemberMappingData memberMappingData)
{
MemberMappingData = memberMappingData;
_parentSourceMember = null;
MatchingSourceMember = null;
SourceMemberMatch = null;
return(this);
}
private SourceMemberDataSource(IQualifiedMember sourceMember, Expression value, IMemberMapperData mapperData)
: base(
sourceMember,
mapperData.MapperContext.ValueConverters.GetConversion(value, mapperData.TargetMember.Type),
mapperData)
{
SourceMemberTypeTest = CreateSourceMemberTypeTest(value, mapperData);
}
public DictionarySourceMember(IQualifiedMember wrappedSourceMember, QualifiedMember matchedTargetMember)
: this(
wrappedSourceMember.Type.GetDictionaryType(),
wrappedSourceMember,
matchedTargetMember,
wrappedSourceMember.Matches(matchedTargetMember))
{
}
public string GetIgnoreMessage(IQualifiedMember targetMember)
{
if (HasMemberFilter)
{
return($"{targetMember.Name} is ignored by filter:{Environment.NewLine}{TargetMemberFilter}");
}
return(targetMember.Name + " is ignored");
}
public override bool Matches(IQualifiedMember otherMember)
{
if (_key == null)
{
return(base.Matches(otherMember));
}
return(GetKeyNameOrNull() == otherMember.Name);
}
public SourceMemberMetaMemberPart(
IQualifiedMember sourceMember,
IMemberMapperData parentMapperData,
bool isRootMemberPart)
: base(parentMapperData)
{
_isRootMemberPart = isRootMemberPart;
SourceMember = sourceMember.RelativeTo(parentMapperData.SourceMember);
}
public FixedMembersMembersSource(
IQualifiedMember sourceMember,
QualifiedMember targetMember,
int dataSourceIndex = 0)
{
_sourceMember = sourceMember;
_targetMember = targetMember;
DataSourceIndex = dataSourceIndex;
}
public static Expression GetRelativeQualifiedAccess(
this IQualifiedMember member,
IMemberMapperData mapperData,
out IQualifiedMember relativeMember)
{
relativeMember = member.RelativeTo(mapperData.SourceMember);
var qualifiedAccess = relativeMember.GetQualifiedAccess(mapperData);
return(qualifiedAccess);
}
public IQualifiedMember RelativeTo(IQualifiedMember otherMember)
{
return(new DictionarySourceMember(
Type,
_wrappedSourceMember.RelativeTo(otherMember),
_matchedTargetMember,
IsEntireDictionaryMatch,
KeyType,
ValueType));
}
protected DataSourceBase(
IQualifiedMember sourceMember,
Expression value,
IMemberMapperData mapperData)
{
SourceMember = sourceMember;
Variables = Constants.EmptyParameters;
Condition = GetCondition(value, mapperData);
Value = value;
}
private static IQualifiedMember GetFinalSourceMember(
IQualifiedMember sourceMember,
IChildMemberMappingData targetData)
{
return(targetData
.MapperData
.MapperContext
.QualifiedMemberFactory
.GetFinalSourceMember(sourceMember, targetData.MapperData.TargetMember));
}
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 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 SourceMemberDataSource(
IQualifiedMember sourceMember,
Expression sourceMemberValue,
IMemberMapperData mapperData)
: base(
sourceMember,
mapperData.GetValueConversion(sourceMemberValue, mapperData.TargetMember.Type),
mapperData)
{
SourceMemberTypeTest = CreateSourceMemberTypeTest(sourceMemberValue, mapperData);
}
