private static void EmitCreateTargetInstance(Type targetType, TypeBuilder typeBuilder)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(CreateTargetInstanceMethod, OverrideProtected, targetType, Type.EmptyTypes);
var codeGenerator = new CodeGenerator(methodBuilder.GetILGenerator());
IEmitterType result = targetType.IsValueType ? EmitValueType(targetType, codeGenerator) : EmitRefType(targetType);
EmitReturn.Return(result, targetType).Emit(codeGenerator);
}
private static void EmitCreateTargetInstance(Type targetType, TypeBuilder typeBuilder)
{
var methodBuilder = typeBuilder.DefineMethod(CreateTargetInstanceMethod, OVERRIDE_PROTECTED, targetType, Type.EmptyTypes);
var codeGenerator = new CodeGenerator(methodBuilder.GetILGenerator());
var result = Helpers.IsValueType(targetType) ? EmitValueType(targetType, codeGenerator) : EmitRefType(targetType);
EmitReturn.Return(result, targetType).Emit(codeGenerator);
}
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 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,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
Type sourceItemType = typePair.Source.GetCollectionItemType();
Type targetItemType = typePair.Target.GetCollectionItemType();
EmitConvertItem(typeBuilder, new TypePair(sourceItemType, targetItemType));
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, targetItemType);
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()));
}
private void EmitEnumerableToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
TypePair collectionItemTypePair,
string methodName,
string templateMethodName)
{
var methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
EmitConvertItem(typeBuilder, collectionItemTypePair);
var methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target);
var returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}