private IEmitter Build(TypePair parentTypePair, MappingMemberPath memberPath)
{
if (memberPath.OneLevelTarget)
{
var sourceObject = EmitArgument.Load(memberPath.TypePair.Source, 1);
var targetObject = EmitArgument.Load(memberPath.TypePair.Target, 2);
var sourceMember = LoadMember(memberPath.Source, sourceObject, memberPath.Source.Count);
var targetMember = LoadMember(memberPath.Target, targetObject, memberPath.Target.Count);
IEmitterType convertedMember = ConvertMember(parentTypePair, memberPath.Tail, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(memberPath.Tail, targetObject, convertedMember);
return(result);
}
else
{
var targetObject = EmitArgument.Load(memberPath.Head.TypePair.Target, 2);
var targetMember = LoadMember(memberPath.Target, targetObject, memberPath.Target.Count - 1);
var sourceObject = EmitArgument.Load(memberPath.Head.TypePair.Source, 1);
var sourceMember = LoadMember(memberPath.Source, sourceObject, memberPath.Source.Count);
IEmitterType convertedMember = ConvertMember(parentTypePair, memberPath.Tail, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(memberPath.Tail, targetMember, convertedMember);
return(result);
}
}
private void EmitConvertItem(TypeBuilder typeBuilder, TypePair typePair, string methodName = ConvertItemMethod)
{
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(typePair);
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typeof(object), new[] { typeof(object) });
IEmitterType sourceMemeber = EmitArgument.Load(typeof(object), 1);
IEmitterType targetMember = EmitNull.Load();
IEmitterType callMapMethod = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
EmitReturn.Return(callMapMethod).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private IEmitter Build(MappingMember member)
{
IEmitterType sourceObject = EmitArgument.Load(member.TypePair.Source, 1);
IEmitterType targetObject = EmitArgument.Load(member.TypePair.Target, 2);
IEmitterType sourceMember = LoadMember(member.Source, sourceObject);
IEmitterType targetMember = LoadMember(member.Target, targetObject);
IEmitterType convertedMember = ConvertMember(member, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(member, targetObject, convertedMember);
return(result);
}
private Option <MapperCache> EmitMapClass(TypePair typePair, TypeBuilder typeBuilder)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(MapClassMethod, OverrideProtected, typePair.Target,
new[] { typePair.Source, typePair.Target });
var codeGenerator = new CodeGenerator(methodBuilder.GetILGenerator());
var emitterComposite = new EmitComposite();
MemberEmitterDescription emitterDescription = EmitMappingMembers(typePair);
emitterComposite.Add(emitterDescription.Emitter);
emitterComposite.Add(EmitReturn.Return(EmitArgument.Load(typePair.Target, 2)));
emitterComposite.Emit(codeGenerator);
return(emitterDescription.MapperCache);
}
private void EmitEnumerableToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
TypePair collectionItemTypePair,
string methodName,
string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
EmitConvertItem(typeBuilder, collectionItemTypePair);
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitDictionaryToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
string methodName,
string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
KeyValuePair <Type, Type> sourceTypes = typePair.Source.GetDictionaryItemTypes();
KeyValuePair <Type, Type> targetTypes = typePair.Target.GetDictionaryItemTypes();
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Key, targetTypes.Key), ConvertItemKeyMethod);
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Value, targetTypes.Value));
var arguments = new[] { sourceTypes.Key, sourceTypes.Value, targetTypes.Key, targetTypes.Value };
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, arguments);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}