private static IEnumerable <DictionaryTargetMember> EnumerateTargetMembers( IEnumerable <Member> sourceMembers, DictionaryTargetMember targetDictionaryMember, ObjectMapperData mapperData, Func <Member, string> targetMemberNameFactory) { foreach (var sourceMember in sourceMembers) { var targetEntryMemberName = targetMemberNameFactory.Invoke(sourceMember); var targetEntryMember = targetDictionaryMember.Append(sourceMember.DeclaringType, targetEntryMemberName); if (targetDictionaryMember.HasObjectEntries) { targetEntryMember = (DictionaryTargetMember)targetEntryMember.WithType(sourceMember.Type); } var entryMapperData = new ChildMemberMapperData(targetEntryMember, mapperData); var configuredKey = GetCustomKeyOrNull(entryMapperData); if (configuredKey != null) { targetEntryMember.SetCustomKey(configuredKey); } if (!sourceMember.IsSimple && !targetDictionaryMember.HasComplexEntries) { targetEntryMember = targetEntryMember.WithTypeOf(sourceMember); } yield return(targetEntryMember); } }
public MemberPopulationContext With(QualifiedMember targetMember) { MemberMapperData = new ChildMemberMapperData(targetMember, MapperData); _memberIgnore = null; _memberIgnoreChecked = false; return(this); }
private static IMemberPopulator Create(QualifiedMember targetMember, IObjectMappingData mappingData) { var childMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData); if (childMapperData.TargetMemberIsUnmappable(out var reason)) { return(MemberPopulator.Unmappable(childMapperData, reason)); } if (TargetMemberIsUnconditionallyIgnored( childMapperData, out var configuredIgnore, out var populateCondition)) { return(MemberPopulator.IgnoredMember(childMapperData, configuredIgnore)); } var childMappingData = mappingData.GetChildMappingData(childMapperData); var dataSources = DataSourceFinder.FindFor(childMappingData); if (dataSources.None) { return(MemberPopulator.NoDataSource(childMapperData)); } return(MemberPopulator.WithRegistration(childMappingData, dataSources, populateCondition)); }
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember) { if (!valueLambdaInfo.TryGetSourceMember(out var sourceMemberLambda)) { return; } var mappingData = _configInfo.ToMappingData <TSource, TTarget>(); var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData); var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData); var bestSourceMemberMatch = SourceMemberMatcher.GetMatchFor(targetMemberMappingData); if (!bestSourceMemberMatch.IsUseable) { return; } var configuredSourceMember = sourceMemberLambda.ToSourceMember(MapperContext); if (!bestSourceMemberMatch.SourceMember.Matches(configuredSourceMember)) { return; } throw new MappingConfigurationException(string.Format( CultureInfo.InvariantCulture, "Source member {0} will automatically be mapped to target {1} {2}, " + "and does not need to be configured", GetSourceMemberDescription(configuredSourceMember), GetTargetMemberType(targetMember), targetMember.GetFriendlyTargetPath(_configInfo))); }
private static IMemberPopulation Create(Member targetMember, IObjectMappingData mappingData) { var qualifiedMember = mappingData.MapperData.TargetMember.Append(targetMember); var childMapperData = new ChildMemberMapperData(qualifiedMember, mappingData.MapperData); Expression populateCondition; if (TargetMemberIsUnconditionallyIgnored(childMapperData, out populateCondition)) { return(MemberPopulation.IgnoredMember(childMapperData)); } var childMappingData = mappingData.GetChildMappingData(childMapperData); var dataSources = childMapperData .MapperContext .DataSources .FindFor(childMappingData); if (dataSources.None) { return(MemberPopulation.NoDataSource(childMapperData)); } return(new MemberPopulation(childMapperData, dataSources, populateCondition)); }
public IEnumerable <IDataSource> FindFor(DataSourceFindContext context) { if (context.MapperData.TargetMember.IsCustom) { yield break; } var matchingSourceMemberDataSource = GetSourceMemberDataSourceOrNull(context); var configuredDataSources = context.ConfiguredDataSources; var targetMember = context.MapperData.TargetMember; if ((matchingSourceMemberDataSource == null) || configuredDataSources.Any(cds => cds.IsSameAs(matchingSourceMemberDataSource))) { if (context.DataSourceIndex == 0) { if (UseFallbackComplexTypeMappingDataSource(targetMember)) { yield return(new ComplexTypeMappingDataSource(context.DataSourceIndex, context.ChildMappingData)); } } else if (configuredDataSources.Any() && configuredDataSources.Last().IsConditional) { yield return(context.GetFallbackDataSource()); } yield break; } if (matchingSourceMemberDataSource.SourceMember.IsSimple && context.MapperData.MapperContext.UserConfigurations.HasConfiguredRootDataSources) { var updatedMapperData = new ChildMemberMapperData( matchingSourceMemberDataSource.SourceMember, targetMember, context.MapperData.Parent); var configuredRootDataSources = context .MapperData .MapperContext .UserConfigurations .GetDataSources(updatedMapperData); foreach (var configuredRootDataSource in configuredRootDataSources) { yield return(configuredRootDataSource); } } yield return(matchingSourceMemberDataSource); if (!targetMember.IsReadOnly && matchingSourceMemberDataSource.IsConditional && (matchingSourceMemberDataSource.IsValid || configuredDataSources.Any())) { yield return(context.GetFallbackDataSource()); } }
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()); } }
private IQualifiedMember GetMatchingSourceMember <TSource, TTarget>( TSource source, TTarget target, Expression <Func <TTarget, object> > childMemberExpression) { var targetMember = TargetMemberFor(childMemberExpression); var mappingContext = new SimpleMappingContext(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext); var rootMappingData = ObjectMappingDataFactory.ForRoot(source, target, mappingContext); var rootMapperData = rootMappingData.MapperData; var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData); var childMappingContext = rootMappingData.GetChildMappingData(childMapperData); return(SourceMemberMatcher.GetMatchFor(childMappingContext, out _)); }
private static IDataSourceSet[] GetArgumentDataSources(TInvokable invokable, ConstructionKey key) { return(invokable .GetParameters() .ProjectToArray(key.MappingData, (mappingData, p) => { var parameterMapperData = new ChildMemberMapperData( mappingData.MapperData.TargetMember.Append(Member.ConstructorParameter(p)), mappingData.MapperData); var memberMappingData = mappingData.GetChildMappingData(parameterMapperData); var dataSources = DataSourceSetFactory.CreateFor(new DataSourceFindContext(memberMappingData)); return dataSources; })); }
private static Tuple <QualifiedMember, DataSourceSet>[] GetArgumentDataSources(TInvokable invokable, ConstructionKey key) { return(invokable .GetParameters() .ProjectToArray(p => { var parameterMapperData = new ChildMemberMapperData( key.MappingData.MapperData.TargetMember.Append(Member.ConstructorParameter(p)), key.MappingData.MapperData); var memberMappingData = key.MappingData.GetChildMappingData(parameterMapperData); var dataSources = DataSourceFinder.FindFor(memberMappingData); return Tuple.Create(memberMappingData.MapperData.TargetMember, dataSources); })); }
private Expression GetPopulation( Expression elementMapping, QualifiedMember dictionaryEntryMember, IObjectMappingData mappingData) { var elementMapperData = new ChildMemberMapperData(dictionaryEntryMember, MapperData); var sourceMember = mappingData.MapperData.SourceMember; var mappingDataSource = new AdHocDataSource(sourceMember, elementMapping); var dataSourceSetInfo = new SimpleDataSourceSetInfo(mappingData.MappingContext, elementMapperData); var mappingDataSources = DataSourceSet.For(mappingDataSource, dataSourceSetInfo); var populator = new MemberPopulator(mappingDataSources, elementMapperData); var populationExpression = populator.GetPopulation(); return(populationExpression); }
private Expression GetPopulation( Expression elementMapping, QualifiedMember dictionaryEntryMember, IObjectMappingData mappingData) { var elementMapperData = new ChildMemberMapperData(dictionaryEntryMember, MapperData); var sourceMember = mappingData.MapperData.SourceMember; var mappingDataSource = new AdHocDataSource(sourceMember, elementMapping); var mappingDataSources = DataSourceSet.For(mappingDataSource, elementMapperData); var populationExpression = MemberPopulator .WithoutRegistration(mappingDataSources) .GetPopulation(); return(populationExpression); }
private IList <ConfiguredDataSourceFactoryBase> GetRelevantConfiguredDataSourceFactories() { var relevantDataSourceFactories = GetRelevantConfiguredDataSourceFactories(MemberMapperData); if (!MemberMapperData.Parent.Context.IsForToTargetMapping) { return(relevantDataSourceFactories); } var originalChildMapperData = new ChildMemberMapperData( TargetMember, MemberMapperData.Parent.OriginalMapperData); relevantDataSourceFactories = relevantDataSourceFactories.Append( GetRelevantConfiguredDataSourceFactories(originalChildMapperData)); return(relevantDataSourceFactories); }
public DataSourceFindContext(IChildMemberMappingData childMappingData) { ChildMappingData = childMappingData; ConfiguredDataSources = GetConfiguredDataSources(MapperData); if (!MapperData.Parent.Context.IsForToTargetMapping) { return; } var originalChildMapperData = new ChildMemberMapperData( MapperData.TargetMember, MapperData.Parent.OriginalMapperData); ConfiguredDataSources = ConfiguredDataSources.Append( GetConfiguredDataSources(originalChildMapperData)); }
public void ShouldNotMatchSameNameIncompatibleTypeProperties() { var source = new TwoValues { Value = new int[5], value = string.Empty }; var target = new PublicProperty <byte>(); var targetMember = TargetMemberFor <PublicProperty <byte> >(x => x.Value); var mappingContext = new MappingExecutor <TwoValues>(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext); var rootMappingData = mappingContext.CreateRootMappingData(source, target); var rootMapperData = rootMappingData.MapperData; var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData); var childMappingContext = rootMappingData.GetChildMappingData(childMapperData); var matchingSourceMember = SourceMemberMatcher.GetMatchFor(childMappingContext); matchingSourceMember.ShouldNotBeNull(); matchingSourceMember.Name.ShouldBe("value"); }
protected ConstructionDataInfo( TInvokable invokable, ConstructionKey key, int priority) { var parameters = invokable.GetParameters(); Priority = priority; ParameterCount = parameters.Length; _argumentTargetMembers = new QualifiedMember[ParameterCount]; ArgumentDataSources = new IDataSourceSet[ParameterCount]; CanBeInvoked = IsUnconditional = true; var mappingData = key.MappingData; var mapperData = mappingData.MapperData; for (var i = 0; i < ParameterCount; ++i) { var argumentMember = Member.ConstructorParameter(parameters[i]); var targetMember = _argumentTargetMembers[i] = mapperData.TargetMember.Append(argumentMember); var argumentMapperData = new ChildMemberMapperData(targetMember, mapperData); var argumentMappingData = mappingData.GetChildMappingData(argumentMapperData); var dataSources = ArgumentDataSources[i] = MemberDataSourceSetFactory .CreateFor(new DataSourceFindContext(argumentMappingData)); if (CanBeInvoked && !dataSources.HasValue) { CanBeInvoked = false; } if (IsUnconditional && dataSources.IsConditional && argumentMember.IsComplex) { IsUnconditional = false; } } }
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember) { if (!valueLambdaInfo.IsSourceMember(out var sourceMemberLambda)) { return; } var mappingData = _configInfo.ToMappingData <TSource, TTarget>(); var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData); var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData); var bestMatchingSourceMember = SourceMemberMatcher.GetMatchFor(targetMemberMappingData, out _); if (bestMatchingSourceMember == null) { return; } var sourceMember = sourceMemberLambda.ToSourceMember(MapperContext); if (!bestMatchingSourceMember.Matches(sourceMember)) { return; } var targetMemberType = (targetMember.LeafMember.MemberType == MemberType.ConstructorParameter) ? "constructor parameter" : "member"; throw new MappingConfigurationException(string.Format( CultureInfo.InvariantCulture, "Source member {0} will automatically be mapped to target {1} {2}, " + "and does not need to be configured", GetSourceMemberDescription(sourceMember), targetMemberType, targetMember.GetFriendlyTargetPath(_configInfo))); }
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 = (sm, tm, md, c) => c.ChildMappingData.Parent; for (var i = memberNameParts.Count - 1; i >= 0; --i) { var memberNamePart = memberNameParts[i]; switch (memberNamePart) { case HasMetaMemberPart.Name: if (HasMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart)) { break; } return(false); case FirstMetaMemberPart.Name: currentMemberPart = new FirstMetaMemberPart(context.MapperData); break; case LastMetaMemberPart.Name: currentMemberPart = new LastMetaMemberPart(context.MapperData); break; case CountMetaMemberPart.Name: if (CountMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart)) { break; } return(false); case NumberOfMetaMemberPart.Name: if (NumberOfMetaMemberPart.TryCreateFor(context.MapperData, 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(m => m.Name == memberNamePart); if (matchingTargetMember == null) { matchingTargetMember = GlobalContext.Instance .MemberCache .GetSourceMembers(currentMapperData.SourceType) .FirstOrDefault(m => m.Name == memberNamePart); if (matchingTargetMember == null) { return(false); } } currentTargetMember = currentMapperData.TargetMember.Append(matchingTargetMember); var childMemberMapperData = new ChildMemberMapperData(currentTargetMember, currentMapperData); var memberMappingData = currentMappingData.GetChildMappingData(childMemberMapperData); currentSourceMember = SourceMemberMatcher.GetMatchFor( memberMappingData, out _, searchParentContexts: false); if (currentSourceMember == null) { return(false); } 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) : ObjectMappingDataFactory.ForChild(sm, tm, 0, md)); }; break; } if (metaMember == null) { metaMember = currentMemberPart; continue; } if (!metaMember.TrySetNextPart(currentMemberPart)) { return(false); } } return(true); }
public Expression GetNewObjectCreation(IObjectMappingData mappingData) { var objectCreation = _constructorsCache.GetOrAdd(new ConstructionKey(mappingData), key => { var mapperData = key.MappingData.MapperData; var constructions = new List <Construction>(); var newingConstructorRequired = true; var configuredFactories = mapperData .MapperContext .UserConfigurations .GetObjectFactories(mapperData); foreach (var configuredFactory in configuredFactories) { var configuredConstruction = new Construction(configuredFactory, mapperData); constructions.Add(configuredConstruction); if (configuredConstruction.IsUnconditional) { newingConstructorRequired = false; break; } } if (newingConstructorRequired) { var greediestAvailableConstructor = mapperData.InstanceVariable.Type .GetPublicInstanceConstructors() .Select(ctor => new ConstructorData( ctor, ctor.GetParameters() .Select(p => { var parameterMapperData = new ChildMemberMapperData( mapperData.TargetMember.Append(Member.ConstructorParameter(p)), mapperData); return(key.MappingData.GetChildMappingData(parameterMapperData)); }) .Select(memberMappingData => { var dataSources = mapperData .MapperContext .DataSources .FindFor(memberMappingData); return(Tuple.Create(memberMappingData.MapperData.TargetMember, dataSources)); }) .ToArray())) .Where(ctor => ctor.CanBeConstructed) .OrderByDescending(ctor => ctor.NumberOfParameters) .FirstOrDefault(); if (greediestAvailableConstructor != null) { foreach (var memberAndDataSourceSet in greediestAvailableConstructor.ArgumentDataSources) { key.MappingData.MapperData.RegisterTargetMemberDataSourcesIfRequired( memberAndDataSourceSet.Item1, memberAndDataSourceSet.Item2); } constructions.Add(greediestAvailableConstructor.Construction); } } if (constructions.None()) { key.MappingData = null; return(null); } var compositeConstruction = new Construction(constructions, key); key.MappingData = null; return(compositeConstruction); }); if (objectCreation == null) { return(null); } mappingData.MapperData.Context.UsesMappingDataObjectAsParameter = objectCreation.UsesMappingDataObjectParameter; var creationExpression = objectCreation.GetConstruction(mappingData); return(creationExpression); }