public DictionaryEntrySourceMember(
Type entryType,
QualifiedMember matchedTargetMember,
DictionarySourceMember parent)
: this(
entryType,
() => parent.GetPath() + "['" + matchedTargetMember.Name + "']",
matchedTargetMember,
parent)
{
var entryMember = Member.RootSource(entryType);
_childMembers = new[] { entryMember };
IsEnumerable = entryMember.IsEnumerable;
IsSimple = !IsEnumerable && entryMember.IsSimple;
}
private QualifiedMember GetTargetMember(Member member, IBasicMapperData mapperData)
{
if (mapperData.TargetMember.LeafMember == member)
{
return(mapperData.TargetMember);
}
var memberIndex = Array.LastIndexOf(mapperData.TargetMember.MemberChain, member);
var targetMemberChain = new Member[memberIndex + 1];
for (var i = 0; i < targetMemberChain.Length; i++)
{
targetMemberChain[i] = mapperData.TargetMember.MemberChain[i];
}
return(QualifiedMember.From(targetMemberChain, ConfigInfo.MapperContext));
}
private Expression GetPopulation(
Expression elementMapping,
QualifiedMember dictionaryEntryMember,
IObjectMappingData mappingData)
{
var elementMapperData = new ChildMemberMapperData(dictionaryEntryMember, MapperData);
var elementMappingData = mappingData.GetChildMappingData(elementMapperData);
var sourceMember = mappingData.MapperData.SourceMember;
var mappingDataSource = new AdHocDataSource(sourceMember, elementMapping);
var mappingDataSources = new DataSourceSet(elementMapperData, mappingDataSource);
var memberPopulation = MemberPopulator.WithoutRegistration(elementMappingData, mappingDataSources);
var populationExpression = memberPopulation.GetPopulation();
return(populationExpression);
}
private static QualifiedMember[] GetConfiguredTargetMembers(
IEnumerable <ConfiguredDictionaryEntryDataSourceFactory> configuredDataSourceFactories,
IList <QualifiedMember> targetMembersFromSource)
{
return(configuredDataSourceFactories
.GroupBy(dsf => dsf.TargetDictionaryEntryMember.Name)
.Project(targetMembersFromSource, (tmfs, group) =>
{
QualifiedMember targetMember = group.First().TargetDictionaryEntryMember;
targetMember.IsCustom = tmfs.None(
targetMember.Name,
(tmn, sourceMember) => sourceMember.RegistrationName == tmn);
return targetMember.IsCustom ? targetMember : null;
})
.WhereNotNull()
.ToArray());
}
internal static IEnumerable <TypeMatchSpec> ReadTypesAndMembers(AnalyzerOptions analyzerOptions, Regex fileNamePattern, CancellationToken cancellationToken)
{
foreach (string line in ReadAdditionalFiles(analyzerOptions, fileNamePattern, cancellationToken))
{
Match match = NegatableTypeOrMemberReferenceRegex.Match(line);
if (!match.Success)
{
throw new InvalidOperationException($"Parsing error on line: {line}");
}
bool inverted = match.Groups["negated"].Success;
string[] typeNameElements = match.Groups["typeName"].Value.Split(QualifiedIdentifierSeparators);
string typeName = typeNameElements[typeNameElements.Length - 1];
var containingNamespace = typeNameElements.Take(typeNameElements.Length - 1).ToImmutableArray();
var type = new QualifiedType(containingNamespace, typeName);
QualifiedMember member = match.Groups["memberName"].Success ? new QualifiedMember(type, match.Groups["memberName"].Value) : default(QualifiedMember);
yield return(new TypeMatchSpec(type, member, inverted));
}
}
private static bool UseComplexTypeDataSource(IDataSource dataSource, QualifiedMember targetMember)
{
if (!targetMember.IsComplex)
{
return(false);
}
if (targetMember.IsDictionary)
{
return(true);
}
if (targetMember.Type == typeof(object))
{
return(!dataSource.SourceMember.Type.IsSimple());
}
return(!targetMember.Type.IsFromBcl());
}
public Expression GetBody(
IMemberMapperData mapperData,
CallbackPosition?position = null,
QualifiedMember targetMember = null)
{
var contextTypes = _contextTypes;
if (_isForTargetDictionary &&
(mapperData.TargetMember is DictionaryTargetMember dictionaryMember) &&
(dictionaryMember.HasCompatibleType(contextTypes[1])))
{
contextTypes = contextTypes.CopyToArray();
contextTypes[1] = mapperData.TargetType;
}
return(position.IsPriorToObjectCreation(targetMember)
? _parametersSwapper.Swap(_lambda, contextTypes, mapperData, ParametersSwapper.UseTargetMember)
: _parametersSwapper.Swap(_lambda, contextTypes, mapperData, ParametersSwapper.UseTargetInstance));
}
protected MemberMapperDataBase(
MappingRuleSet ruleSet,
IQualifiedMember sourceMember,
QualifiedMember targetMember,
ObjectMapperData parent,
MapperContext mapperContext)
: base(
ruleSet,
sourceMember.Type,
targetMember.Type,
sourceMember,
targetMember,
parent,
mapperContext)
{
Parent = parent;
MappingDataObject = CreateMappingDataObject();
MappingDataType = typeof(IMappingData <,>).MakeGenericType(SourceType, TargetType);
SourceObject = GetMappingDataProperty(MappingDataType, Member.RootSourceMemberName);
TargetObject = GetMappingDataProperty(Member.RootTargetMemberName);
}
public static IObjectMappingData ForChild(
IQualifiedMember sourceMember,
QualifiedMember targetMember,
int dataSourceIndex,
IObjectMappingData parent)
{
var key = new SourceAndTargetTypesKey(sourceMember.Type, targetMember.Type);
var typedForChildCaller = GlobalContext.Instance.Cache.GetOrAdd(key, k =>
{
var bridgeParameter = Expression.Parameter(typeof(IObjectMappingDataFactoryBridge), "bridge");
var childMembersSourceParameter = Expression.Parameter(typeof(object), "childMembersSource");
var parentParameter = Expression.Parameter(typeof(object), "parent");
var typedForChildMethod = bridgeParameter.Type
.GetPublicInstanceMethod("ForChild")
.MakeGenericMethod(k.SourceType, k.TargetType);
var typedForChildCall = Expression.Call(
bridgeParameter,
typedForChildMethod,
childMembersSourceParameter,
parentParameter);
var typedForChildLambda = Expression.Lambda <Func <IObjectMappingDataFactoryBridge, object, object, object> >(
typedForChildCall,
bridgeParameter,
childMembersSourceParameter,
parentParameter);
return(typedForChildLambda.Compile());
},
default(HashCodeComparer <SourceAndTargetTypesKey>));
var membersSource = new FixedMembersMembersSource(sourceMember, targetMember, dataSourceIndex);
return((IObjectMappingData)typedForChildCaller.Invoke(_bridge, membersSource, parent));
}
public Expression GetConditionOrNull(
IMemberMapperData mapperData,
CallbackPosition position,
QualifiedMember targetMember)
{
if (!HasCondition)
{
return(GetTypeCheckConditionOrNull(mapperData));
}
var condition = _conditionLambda.GetBody(mapperData, position, targetMember);
if (_negateCondition)
{
condition = Expression.Not(condition);
}
var targetCanBeNull = position.IsPriorToObjectCreation(targetMember);
var conditionNestedAccessesChecks = mapperData
.GetNestedAccessesIn(condition, targetCanBeNull)
.GetIsNotDefaultComparisonsOrNull();
if (conditionNestedAccessesChecks != null)
{
condition = Expression.AndAlso(conditionNestedAccessesChecks, condition);
}
var typeCheck = GetTypeCheckConditionOrNull(mapperData);
if (typeCheck != null)
{
condition = Expression.AndAlso(typeCheck, condition);
}
return(condition);
}
public static EnumMappingMismatchSet For(
QualifiedMember targetMember,
IEnumerable <IDataSource> dataSources,
IMemberMapperData mapperData)
{
var sourceEnumData = dataSources
.Project(ds => new
{
DataSource = ds,
EnumType = ds.SourceMember.Type.GetNonNullableType()
})
.GroupBy(dss => dss.EnumType)
.Project(dsGroup => new
{
EnumType = dsGroup.Key,
SourceMembers = dsGroup.Project(ds => ds.DataSource.SourceMember).ToArray()
})
.ToArray();
var targetEnumType = targetMember.Type.GetNonNullableType();
var targetEnumNames = Enum.GetNames(targetEnumType);
var mappingMismatches = sourceEnumData
.Filter(targetEnumType, (tet, d) => d.EnumType != tet)
.Project(d => EnumMappingMismatch.For(
d.EnumType,
d.SourceMembers,
targetEnumType,
targetEnumNames,
targetMember,
mapperData))
.Filter(mm => mm.Any)
.ToArray();
return(mappingMismatches.Any() ? new EnumMappingMismatchSet(mappingMismatches) : _emptySet);
}
private ObjectMapperData(
IObjectMappingData mappingData,
IQualifiedMember sourceMember,
QualifiedMember targetMember,
int?dataSourceIndex,
ObjectMapperData declaredTypeMapperData,
ObjectMapperData parent,
bool isForStandaloneMapping)
: base(
mappingData.MappingContext.RuleSet,
sourceMember.Type,
targetMember.Type,
targetMember,
parent)
{
MapperContext = mappingData.MappingContext.MapperContext;
DeclaredTypeMapperData = declaredTypeMapperData;
_childMapperDatas = new List <ObjectMapperData>();
DataSourceIndex = dataSourceIndex.GetValueOrDefault();
MappingDataObject = GetMappingDataObject(parent);
SourceMember = sourceMember;
var mappingDataType = typeof(IMappingData <,>).MakeGenericType(SourceType, TargetType);
SourceObject = GetMappingDataProperty(mappingDataType, "Source");
TargetObject = Expression.Property(MappingDataObject, "Target");
CreatedObject = Expression.Property(MappingDataObject, "CreatedObject");
var isPartOfDerivedTypeMapping = declaredTypeMapperData != null;
if (isPartOfDerivedTypeMapping)
{
EnumerableIndex = declaredTypeMapperData.EnumerableIndex;
ParentObject = declaredTypeMapperData.ParentObject;
}
else
{
EnumerableIndex = GetMappingDataProperty(mappingDataType, "EnumerableIndex");
ParentObject = Expression.Property(MappingDataObject, "Parent");
}
NestedAccessFinder = new NestedAccessFinder(MappingDataObject);
_mapChildMethod = GetMapMethod(MappingDataObject.Type, 4);
_mapElementMethod = GetMapMethod(MappingDataObject.Type, 3);
_dataSourcesByTargetMemberName = new Dictionary <string, DataSourceSet>();
DataSourcesByTargetMember = new Dictionary <QualifiedMember, DataSourceSet>();
if (targetMember.IsEnumerable)
{
EnumerablePopulationBuilder = new EnumerablePopulationBuilder(this);
}
else
{
TargetTypeHasNotYetBeenMapped = IsTargetTypeFirstMapping(parent);
TargetTypeWillNotBeMappedAgain = IsTargetTypeLastMapping();
_instanceVariable = Expression
.Variable(TargetType, TargetType.GetVariableNameInCamelCase());
}
ReturnLabelTarget = Expression.Label(TargetType, "Return");
if (isForStandaloneMapping)
{
RequiredMapperFuncsByKey = new Dictionary <ObjectMapperKeyBase, LambdaExpression>();
}
if (IsRoot)
{
Context = new MapperDataContext(this, isForStandaloneMapping, isPartOfDerivedTypeMapping);
return;
}
Context = new MapperDataContext(
this,
isForStandaloneMapping,
isPartOfDerivedTypeMapping || parent.Context.IsForDerivedType);
parent._childMapperDatas.Add(this);
Parent = parent;
}
private ConfiguredMemberIgnore(MappingConfigInfo configInfo, QualifiedMember targetMember)
: base(configInfo, targetMember)
{
}
internal TargetMemberSelector(QualifiedMember targetMember)
{
_targetMember = targetMember;
}
private ObjectMapperData(
IObjectMappingData mappingData,
IQualifiedMember sourceMember,
QualifiedMember targetMember,
int?dataSourceIndex,
ObjectMapperData declaredTypeMapperData,
ObjectMapperData parent,
bool isForStandaloneMapping)
: base(
mappingData.MappingContext.RuleSet,
sourceMember.Type,
targetMember.Type,
sourceMember,
targetMember,
parent)
{
MapperContext = mappingData.MappingContext.MapperContext;
DeclaredTypeMapperData = OriginalMapperData = declaredTypeMapperData;
_childMapperDatas = new List <ObjectMapperData>();
DataSourceIndex = dataSourceIndex.GetValueOrDefault();
MappingDataObject = GetMappingDataObject(parent);
SourceMember = sourceMember;
var mappingDataType = typeof(IMappingData <,>).MakeGenericType(SourceType, TargetType);
SourceObject = GetMappingDataProperty(mappingDataType, RootSourceMemberName);
TargetObject = GetMappingDataProperty(RootTargetMemberName);
CreatedObject = GetMappingDataProperty(nameof(CreatedObject));
var isPartOfDerivedTypeMapping = declaredTypeMapperData != null;
if (isPartOfDerivedTypeMapping)
{
EnumerableIndex = declaredTypeMapperData.EnumerableIndex;
ParentObject = declaredTypeMapperData.ParentObject;
}
else
{
EnumerableIndex = GetMappingDataProperty(mappingDataType, nameof(EnumerableIndex));
ParentObject = GetMappingDataProperty(nameof(Parent));
}
ExpressionInfoFinder = new ExpressionInfoFinder(MappingDataObject);
DataSourcesByTargetMember = new Dictionary <QualifiedMember, DataSourceSet>();
ReturnLabelTarget = Expression.Label(TargetType, "Return");
_mappedObjectCachingMode = MapperContext.UserConfigurations.CacheMappedObjects(this);
if (targetMember.IsEnumerable)
{
EnumerablePopulationBuilder = new EnumerablePopulationBuilder(this);
}
if (IsRoot)
{
TargetTypeHasNotYetBeenMapped = true;
TargetTypeWillNotBeMappedAgain = IsTargetTypeLastMapping(parent);
Context = new MapperDataContext(this, true, isPartOfDerivedTypeMapping);
return;
}
parent._childMapperDatas.Add(this);
Parent = parent;
if (!this.TargetMemberIsEnumerableElement())
{
TargetTypeHasNotYetBeenMapped = IsTargetTypeFirstMapping(parent);
TargetTypeWillNotBeMappedAgain = IsTargetTypeLastMapping(parent);
}
Context = new MapperDataContext(
this,
isForStandaloneMapping,
isPartOfDerivedTypeMapping || parent.Context.IsForDerivedType);
}
public TargetMemberData(QualifiedMember targetMember, IEnumerable <IDataSource> dataSources)
{
TargetMember = targetMember;
DataSources = dataSources;
}
public bool IsFiltered(QualifiedMember member) => _memberFilter.Invoke(new TargetMemberSelector(member));
public bool CouldMatch(QualifiedMember otherMember) => _wrappedSourceMember.CouldMatch(otherMember);
private static bool UseFallbackComplexTypeMappingDataSource(QualifiedMember targetMember) => targetMember.IsComplex && !targetMember.IsDictionary && (targetMember.Type != typeof(object));
protected ConfiguredMemberIgnoreBase(MappingConfigInfo configInfo, QualifiedMember targetMember)
: base(configInfo, targetMember)
{
}
internal MemberSelectorBase(QualifiedMember member)
{
_member = member;
}
public SyncBlockingMethod(QualifiedMember method, string asyncAlternativeMethodName = null, IReadOnlyList <string> extensionMethodNamespace = null)
{
this.Method = method;
this.AsyncAlternativeMethodName = asyncAlternativeMethodName;
this.ExtensionMethodNamespace = extensionMethodNamespace;
}
protected UserConfiguredItemBase(MappingConfigInfo configInfo, QualifiedMember targetMember)
{
ConfigInfo = configInfo;
TargetMember = targetMember;
}
private static bool TargetMemberIsAnEnum(QualifiedMember targetMember) => targetMember.IsSimple && IsEnum(targetMember.Type);
internal QualifiedMember TargetMemberFor <T>(Expression <Func <T, object> > childMemberExpression = null)
{
return((childMemberExpression == null)
? QualifiedMember.From(Member.RootTarget(typeof(T)), DefaultMapperContext)
: childMemberExpression.ToTargetMember(DefaultMapperContext));
}
private static IQualifiedMember SourceMemberFor(Member rootSourceMember, Expression childMemberExpression)
{
return((childMemberExpression == null)
? QualifiedMember.From(rootSourceMember, DefaultMapperContext)
: childMemberExpression.ToSourceMember(DefaultMapperContext));
}
private static string GetNoDataSourcesMessage(QualifiedMember targetMember)
{
return(targetMember.IsSimple
? "No data sources for " + targetMember.Name
: $"No data sources for {targetMember.Name} or any of its child members");
}
internal CustomTargetDictionaryKeySpecifier(MappingConfigInfo configInfo, QualifiedMember sourceMember)
: base(configInfo, sourceMember)
{
}
public static bool IsPriorToObjectCreation(this CallbackPosition?position, QualifiedMember targetMember) => IsPriorToObjectCreation(position.GetValueOrDefault(), targetMember);
protected override bool TargetMembersAreCompatibleForToTarget(QualifiedMember otherTargetMember) => TargetMember.HasCompatibleType(otherTargetMember.Type);
