internal CollectionWithMap(MappingDefinitionInformation mappingDefinition, IEqualityRules equalityRules, bool mapNullToEmpty)
{
this.aItemMapping = mappingDefinition.UnresolvedMappings.GetUnresolvedMapping(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType);
var childPostprocessing = mappingDefinition.GetChildPostprocessing(typeof(TTo), EnumerableReflection <TTo> .ItemType);
if (ArrayMappingCompiler <TFrom, TTo> .ShouldUse())
{
this.aMappingExpression = new ArrayMappingCompiler <TFrom, TTo>(this.aItemMapping, childPostprocessing, mapNullToEmpty);
}
else if (ListMappingCompiler <TFrom, TTo> .ShouldUse())
{
this.aMappingExpression = new ListMappingCompiler <TFrom, TTo>(this.aItemMapping, childPostprocessing, mapNullToEmpty);
}
else if (ConstructorMappingCompiler <TFrom, TTo> .ShouldUse())
{
this.aMappingExpression = new ConstructorMappingCompiler <TFrom, TTo>(this.aItemMapping, childPostprocessing, mapNullToEmpty);
}
else
{
throw new InvalidMappingException($"Cannot find proper method to map to a collection of type {typeof(TTo).FullName}");
}
this.aMapEqualityExpression = new EnumerableComparisionCompiler <TFrom, TTo>(this.aItemMapping, equalityRules, mapNullToEmpty);
}
public IMapping <TFrom, TTo> Create <TFrom, TTo>(MappingDefinitionInformation mappingDefinition)
{
// TODO: support for nullable value types
if (typeof(TFrom).IsValueType || typeof(TTo).IsValueType)
{
throw new InvalidMappingException($"Both source type {typeof(TFrom).Name} and destination type {typeof(TTo).Name} should be reference types");
}
var underlayingMapping = this.aRules.Create <TFrom, TTo>(mappingDefinition);
if (underlayingMapping is IMappingWithSyncSupport <TFrom, TTo> mappingWithSync)
{
return((IMapping <TFrom, TTo>)Activator.CreateInstance(
typeof(NullableWithSync <,>).MakeGenericType(typeof(TFrom), typeof(TTo)),
mappingWithSync
));
}
else
{
return((IMapping <TFrom, TTo>)Activator.CreateInstance(
typeof(NullableWithMap <,>).MakeGenericType(typeof(TFrom), typeof(TTo)),
underlayingMapping
));
}
}
public ObjectToObject(Func <TFrom, TTo> factoryFunction, MappingDefinitionInformation mappingDefinition, IEnumerable <PairedMembers> explicitPairs, bool implicitMappings)
{
PairedMembers[] memberPairs;
if (implicitMappings)
{
var explicitPairArray = explicitPairs.ToArray();
var explicitSymbols = new HashSet <IMember>(explicitPairArray.Select(x => x.To));
memberPairs = explicitPairArray
.Concat(
new TypePairParser(mappingDefinition, typeof(TFrom), typeof(TTo))
.Where(x => !explicitSymbols.Contains(x.To))
)
.ToArray();
}
else
{
memberPairs = explicitPairs.ToArray();
}
this.aMemberPairs = memberPairs;
this.aMappingExpression = new ObjectToObjectMappingCompiler <TFrom, TTo>(mappingDefinition, factoryFunction, memberPairs);
this.aSynchronizationExpression = new ObjectToObjectSynchronizationCompiler <TFrom, TTo>(mappingDefinition, memberPairs);
this.aComparisionExpression = new ObjectToObjectComparisionCompiler <TFrom, TTo>(mappingDefinition, memberPairs);
}
public bool Matches(MappingDefinitionInformation mappingDefinitionInformation, IEnumerable <Type> types)
{
var typeChecker = new TypeChecker();
var typeArray = types as ICollection <Type> ?? types.ToArray();
if (typeArray.Count != this.aPatterns.Length)
{
throw new ArgumentException($"Pattern group should be compared to exactly {this.aPatterns.Length} types.");
}
foreach (var(type, pattern) in typeArray.Zip(this.aPatterns, (type, pattern) => (type, pattern)))
{
if (!pattern.Matches(type, typeChecker))
{
return(false);
}
}
var patternWhereEvaluator = new PatternWhereEvaluator(typeChecker, mappingDefinitionInformation);
foreach (var whereCondition in this.aWhereConditions)
{
if (!whereCondition(patternWhereEvaluator))
{
return(false);
}
}
return(true);
}
public IMapping CreateMapping(MappingDefinitionInformation mappingDefinition, Type from, Type to)
{
if (!this.aPatterns.Matches(mappingDefinition, from, to))
{
throw new InvalidOperationException($"{from.Name} and {to.Name} does not match required patterns");
}
return(this.aRules.Create(from, to, mappingDefinition));
}
public IMapping CreateMapping(MappingDefinitionInformation mappingDefinition, Type from, Type to)
{
if (typeof(TFrom) != from || typeof(TTo) != to)
{
throw new InvalidOperationException($"{from.Name} and {to.Name} does not match required types");
}
return(this.aRules.Create(mappingDefinition));
}
PairedMembers IMemberMappingDefinition.CreateMapping(MappingDefinitionInformation mappingDefinition, Type fromClass, Type toClass)
{
var memberFrom = new MemberFromNameParser(fromClass).ParseRead(this.aFromName);
var memberTo = new MemberFromNameParser(toClass).ParseWrite(this.aToName);
var mapping = mappingDefinition.UnresolvedMappings.GetUnresolvedMapping(memberFrom.Type, memberTo.Type);
return(new PairedMembers(memberFrom, memberTo, mapping));
}
public TypePairParser(MappingDefinitionInformation mappingDefinition, Type from, Type to)
{
this.aMappingDefinition = mappingDefinition;
this.aFrom = from;
this.aTo = to;
this.aFromMembers = new Dictionary <Type, List <IMember> >();
this.aToMembers = new Dictionary <Type, List <IMember> >();
}
internal void SetMappingDefinition(MappingDefinitionInformation mappingDefinition)
{
this.MappingDefinition = mappingDefinition;
foreach (var namingConventions in this.GetChildConventions())
{
namingConventions.SetMappingDefinition(mappingDefinition);
}
}
IMapping <TFrom, TTo> IMappingRules <TFrom, TTo> .Create(MappingDefinitionInformation mappingDefinition)
{
var equalityRules = mappingDefinition.SpecialRules.GetRules <IEqualityRules>(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType);
if (typeof(TTo).IsArray && equalityRules != null)
{
return(new CollectionWithSync <TFrom, TTo>(mappingDefinition, equalityRules, this.aMapNullToEmpty));
}
else
{
return(new CollectionWithMap <TFrom, TTo>(mappingDefinition, null, this.aMapNullToEmpty));
}
}
IMapping <TFrom, TTo> IMappingRules <TFrom, TTo> .Create(MappingDefinitionInformation mappingDefinition)
{
var mapping = this.aRules.Create(mappingDefinition);
if (mapping is IMappingWithSyncSupport <TFrom, TTo> mappingWithSync)
{
return(new PostprocessWithSync <TFrom, TTo>(mappingWithSync, this.aPostprocessDelegate));
}
else
{
return(new PostprocessWithMap <TFrom, TTo>(mapping, this.aPostprocessDelegate));
}
}
IMapping <TFrom, TTo> IMappingRules <TFrom, TTo> .Create(MappingDefinitionInformation mappingDefinition)
{
if (this.aMappingFunc == null)
{
throw new InvalidMappingException("Function mapping without the mapping function defined");
}
if (this.aMappingAction != null)
{
return(new FuncMappingWithSync <TFrom, TTo>(this.aMappingFunc, this.aMappingAction));
}
else
{
return(new FuncMappingWithMap <TFrom, TTo>(this.aMappingFunc));
}
}
internal CollectionWithSync(MappingDefinitionInformation mappingDefinition, IEqualityRules equalityRules, bool mapNullToEmpty)
: base(mappingDefinition, equalityRules, mapNullToEmpty)
{
var itemMapping = mappingDefinition.UnresolvedMappings.GetUnresolvedMapping(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType);
var childPostprocessing = mappingDefinition.GetChildPostprocessing(typeof(TTo), EnumerableReflection <TTo> .ItemType);
if (typeof(TTo).IsArray)
{
this.aSynchronizationExpression = new ArraySynchronizationCompiler <TFrom, TTo>(itemMapping, equalityRules, childPostprocessing, mapNullToEmpty);
}
else
{
throw new NotImplementedException("Only array synchronization supported yet");
}
}
public IMapping <TFrom, TTo> Create(MappingDefinitionInformation mappingDefinition)
{
var underlayingMapping = this.aRules.Create(mappingDefinition);
switch (underlayingMapping)
{
case IDirectMapping _:
return(underlayingMapping);
case IMappingWithSyncSupport <TFrom, TTo> mappingWithSync:
return(new NullableWithSync <TFrom, TTo>(mappingWithSync));
default:
return(new NullableWithMap <TFrom, TTo>(underlayingMapping));
}
}
IMapping <TFrom, TTo> IMappingRules <TFrom, TTo> .Create(MappingDefinitionInformation mappingDefinition)
{
Func <TFrom, TTo> factoryFunction;
if (this.aFactoryFunction == null)
{
factoryFunction = null;
}
else
{
factoryFunction = new Func <TFrom, TTo>(this.aFactoryFunction);
}
var members = this.aExplicitMappings.Select(x => x.CreateMapping(mappingDefinition, typeof(TFrom), typeof(TTo)));
return(new ObjectToObject <TFrom, TTo>(factoryFunction, mappingDefinition, members, this.aUseImplicitMappings));
}
PairedMembers IMemberMappingDefinition.CreateMapping(MappingDefinitionInformation mappingDefinition, Type fromClass, Type toClass)
{
IMember memberFrom;
if (this.aFromName == null)
{
memberFrom = new ThisMember <TFromType>();
}
else
{
memberFrom = new MemberFromNameParser(fromClass).ParseRead(this.aFromName);
}
IMember memberTo;
if (this.aToName == null)
{
memberTo = new ThisMember <TToType>();
}
else
{
memberTo = new MemberFromNameParser(toClass).ParseWrite(this.aToName);
}
IUnresolvedMapping <TFromType, TToType> mapping;
if (this.aRules == null)
{
mapping = mappingDefinition.UnresolvedMappings.GetUnresolvedMapping <TFromType, TToType>();
}
else
{
mapping = this.aRules.Create(mappingDefinition).AsUnresolved();
}
return(new PairedMembers(memberFrom, memberTo, mapping));
}
public ObjectToObjectMappingCompiler(MappingDefinitionInformation mappingDefinition, Func <TFrom, TTo> factoryFunction, IEnumerable <PairedMembers> memberPairs)
{
this.aMemberPairs = memberPairs;
this.aMappingDefinition = mappingDefinition;
this.aFactoryFunction = factoryFunction;
}
IMapping <TFrom, TTo> IMappingRules <TFrom, TTo> .Create(MappingDefinitionInformation mappingDefinition)
{
return(this.aFactory(mappingDefinition));
}
public ObjectToObjectComparisionCompiler(MappingDefinitionInformation mappingDefinition, IEnumerable <PairedMembers> memberPairs)
{
this.aMemberPairs = memberPairs;
this.aMappingDefinition = mappingDefinition;
}
public IMapping <TFrom, TTo> Create <TFrom, TTo>(MappingDefinitionInformation mappingDefinition)
{
return((IMapping <TFrom, TTo>) this.aFactory(mappingDefinition, typeof(TFrom), typeof(TTo)));
}
IMapping <TFrom, TTo> IMappingRules.Create <TFrom, TTo>(MappingDefinitionInformation mappingDefinition)
{
return((IMapping <TFrom, TTo>) new ToString <TFrom>());
}
public bool IsDefinedFor(MappingDefinitionInformation mappingDefinition, Type from, Type to)
{
return(this.aPatterns.Matches(mappingDefinition, from, to));
}
public SubClassToObject(MappingDefinitionInformation mappingDefinition, IEnumerable <(Type From, Type To)> fromTo, IMapping <TFrom, TTo> defaultMapping)
public IMapping <TFromTo, TFromTo> Create(MappingDefinitionInformation mappingDefinition)
{
return(new Copy <TFromTo>());
}
public bool Matches(MappingDefinitionInformation mappingDefinitionInformation, params Type[] types) => this.Matches(mappingDefinitionInformation, types.AsEnumerable());
public IMapping <string, TTo> Create(MappingDefinitionInformation mappingDefinition)
{
return(new Parse <TTo>());
}
internal PatternWhereEvaluator(TypeChecker typeChecker, MappingDefinitionInformation mappingDefinitionInformation)
{
this.aTypeChecker = typeChecker;
this.aMappingDefinitionInformation = mappingDefinitionInformation;
}
public IMapping <TFrom, string> Create(MappingDefinitionInformation mappingDefinition)
{
return(new ToString <TFrom>());
}
public bool IsDefinedFor(MappingDefinitionInformation mappingDefinition, Type @from, Type to)
{
return(from == typeof(TFrom) && to == typeof(TTo));
}
public bool IsDefinedFor(MappingDefinitionInformation mappingDefinition, Type @from, Type to)
{
return(this.From == from && this.To == to);
}
