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); }