private IAstNode ProcessReadWriteSimple(ReadWriteSimple readWriteSimple, int operationId) { IAstRefOrValue sourceValue = ReadSrcMappingValue(readWriteSimple, operationId); IAstRefOrValue convertedValue; if (readWriteSimple.NullSubstitutor != null && (ReflectionUtils.IsNullable(readWriteSimple.Source.MemberType) || !readWriteSimple.Source.MemberType.IsValueType)) { convertedValue = new AstIfTernar( ReflectionUtils.IsNullable(readWriteSimple.Source.MemberType) ? (IAstValue) new AstExprNot(AstBuildHelper.ReadPropertyRV(new AstValueToAddr((IAstValue)sourceValue), readWriteSimple.Source.MemberType.GetProperty("HasValue"))) : new AstExprIsNull(sourceValue), GetNullValue(readWriteSimple.NullSubstitutor), // source is null AstBuildHelper.CastClass( ConvertMappingValue( readWriteSimple, operationId, sourceValue ), readWriteSimple.Destination.MemberType ) ); } else { convertedValue = ConvertMappingValue( readWriteSimple, operationId, sourceValue ); } return(WriteMappingValue(readWriteSimple, operationId, convertedValue)); }
private IAstNode ProcessDestSrcReadOperation( DestSrcReadOperation operation, int operationId) { IAstRefOrValue src = AstBuildHelper.ReadMembersChain( AstBuildHelper.ReadLocalRA(locFrom), operation.Source.MembersChain ); IAstRefOrValue dst = AstBuildHelper.ReadMembersChain( AstBuildHelper.ReadLocalRA(locFrom), operation.Destination.MembersChain ); return(AstBuildHelper.CallMethod( typeof(ValueProcessor).GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(operationId, typeof(DestSrcReadOperation)), typeof(DestWriteOperation).GetProperty("ValueProcessor") ), operation.ValueProcessor.GetType() ), new List <IAstStackItem> { src, dst, AstBuildHelper.ReadLocalRV(locState) } )); }
public AstIfNull(IAstRef value, IAstRefOrValue ifNullValue) { _value = value; _ifNullValue = ifNullValue; if (!_value.itemType.IsAssignableFrom(_ifNullValue.itemType)) { throw new EmitMapperException("Incorrect ifnull expression"); } }
/// <summary> /// Casts the class. /// </summary> /// <param name="value">The value.</param> /// <param name="targetType">The target type.</param> /// <returns>An IAstRefOrValue.</returns> public static IAstRefOrValue CastClass(IAstRefOrValue value, Type targetType) { if (targetType.IsValueType) { return(new AstCastclassValue(value, targetType)); } return(new AstCastclassRef(value, targetType)); }
public AstIfTernar(IAstRefOrValue condition, IAstRefOrValue trueBranch, IAstRefOrValue falseBranch) { if (trueBranch.itemType != falseBranch.itemType) { throw new EmitMapperException("Types mismatch"); } this.condition = condition; this.trueBranch = trueBranch; this.falseBranch = falseBranch; }
private IAstRefOrValue ConvertMappingValue( ReadWriteSimple rwMapOp, int operationId, IAstRefOrValue sourceValue) { IAstRefOrValue convertedValue = sourceValue; if (rwMapOp.Converter != null) { convertedValue = AstBuildHelper.CallMethod( rwMapOp.Converter.GetType().GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(operationId, typeof(ReadWriteSimple)), typeof(ReadWriteSimple).GetProperty("Converter") ), rwMapOp.Converter.GetType() ), new List <IAstStackItem>() { sourceValue, AstBuildHelper.ReadLocalRV(locState), } ); } else { if (rwMapOp.ShallowCopy && rwMapOp.Destination.MemberType == rwMapOp.Source.MemberType) { convertedValue = sourceValue; } else { var mi = staticConvertersManager.GetStaticConverter(rwMapOp.Source.MemberType, rwMapOp.Destination.MemberType); if (mi != null) { convertedValue = AstBuildHelper.CallMethod( mi, null, new List <IAstStackItem> { sourceValue } ); } else { convertedValue = ConvertByMapper(rwMapOp); } } } return(convertedValue); }
public static IAstRefOrValue ReadMembersChain(IAstRefOrAddr sourceObject, MemberInfo[] membersChain) { IAstRefOrAddr src = sourceObject; IAstRefOrValue result = null; for (int i = 0; i < membersChain.Length - 1; ++i) { src = ReadMemberRA(src, membersChain[i]); } result = ReadMemberRV(src, membersChain[membersChain.Length - 1]); return(result); }
public AstWriteProperty(IAstRefOrAddr targetObject, IAstRefOrValue value, PropertyInfo propertyInfo) { _targetObject = targetObject; _value = value; _propertyInfo = propertyInfo; _setMethod = propertyInfo.GetSetMethod(); if (_setMethod == null) { throw new Exception("Property " + propertyInfo.Name + " doesn't have set accessor"); } if (_setMethod.GetParameters().Length != 1) { throw new EmitMapperException("Property " + propertyInfo.Name + " has invalid arguments"); } }
private IAstNode Process_ValuesFilter( IReadWriteOperation op, int operationId, IAstNode result, IAstRefOrValue value, string fieldName, Delegate filterDelegate ) { result = new AstComplexNode { nodes = new List <IAstNode> { new AstIf { condition = (IAstValue)AstBuildHelper.CallMethod( filterDelegate.GetType().GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(operationId, typeof(IReadWriteOperation)), typeof(IReadWriteOperation).GetProperty(fieldName) ), filterDelegate.GetType() ), new List <IAstStackItem>() { value, AstBuildHelper.ReadLocalRV(locState), } ), trueBranch = new AstComplexNode { nodes = new List <IAstNode> { result } } } } }; return(result); }
/// <summary> /// Writes the members chain. /// </summary> /// <param name="membersChain">The members chain.</param> /// <param name="targetObject">The target object.</param> /// <param name="value">The value.</param> /// <returns>An IAstNode.</returns> public static IAstNode WriteMembersChain( IEnumerable <MemberInfo> membersChain, IAstRefOrAddr targetObject, IAstRefOrValue value) { var readTarget = targetObject; var enumerator = membersChain.GetEnumerator(); MemberInfo cur = null; if (enumerator.MoveNext()) { cur = enumerator.Current; } while (enumerator.MoveNext()) { readTarget = ReadMemberRA(readTarget, cur); cur = enumerator.Current; } return(WriteMember(cur, readTarget, value)); }
private IAstNode WriteMappingValue( IMappingOperation mappingOperation, int mappingItemId, IAstRefOrValue value) { IAstNode writeValue; if (mappingOperation is SrcReadOperation) { writeValue = AstBuildHelper.CallMethod( typeof(ValueSetter).GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(mappingItemId, typeof(SrcReadOperation)), typeof(SrcReadOperation).GetProperty("Setter") ), (mappingOperation as SrcReadOperation).Setter.GetType() ), new List <IAstStackItem>() { AstBuildHelper.ReadLocalRV(locTo), value, AstBuildHelper.ReadLocalRV(locState), } ); } else { writeValue = AstBuildHelper.WriteMembersChain( (mappingOperation as IDestOperation).Destination.MembersChain, AstBuildHelper.ReadLocalRA(locTo), value ); } return(writeValue); }
/// <summary> /// Initializes a new instance of the <see cref="AstWriteLocal" /> class. /// </summary> /// <param name="loc">The loc.</param> /// <param name="value">The value.</param> public AstWriteLocal(LocalVariableInfo loc, IAstRefOrValue value) { LocalIndex = loc.LocalIndex; LocalType = loc.LocalType; Value = value; }
public AstExprNot(IAstRefOrValue value) { _value = value; }
public AstExprIsNull(IAstRefOrValue value) { this.value = value; }
public static IAstRefOrValue Convert( Type destinationType, Type sourceType, IAstRefOrValue sourceValue ) { if (destinationType == sourceValue.itemType) { return sourceValue; } if (destinationType == typeof(string)) { return new AstCallMethodRef( typeof(NativeConverter).GetMethod( "ObjectToString", BindingFlags.NonPublic | BindingFlags.Static ), null, new List<IAstStackItem>() { sourceValue } ); } foreach (var m in typeof(Convert).GetMethods(BindingFlags.Static | BindingFlags.Public)) { if (m.ReturnType == destinationType) { var parameters = m.GetParameters(); if (parameters.Length == 1 && parameters[0].ParameterType == sourceType) { return AstBuildHelper.CallMethod( m, null, new List<IAstStackItem> { sourceValue } ); } } } return AstBuildHelper.CallMethod( typeof(EMConvert).GetMethod( "ChangeType", new[] { typeof(object), typeof(Type), typeof(Type) } ), null, new List<IAstStackItem>{ sourceValue, new AstTypeof(){type = sourceType}, new AstTypeof(){type = destinationType} } ); }
public AstCastclass(IAstRefOrValue value, Type targetType) { Value = value; TargetType = targetType; }
public static IAstNode WriteMember(MemberInfo memberInfo, IAstRefOrAddr targetObject, IAstRefOrValue value) { if (memberInfo.MemberType == MemberTypes.Field) { return(new AstWriteField() { fieldInfo = (FieldInfo)memberInfo, targetObject = targetObject, value = value }); } else { return(new AstWriteProperty(targetObject, value, (PropertyInfo)memberInfo)); } }
public static IAstRefOrValue CastClass(IAstRefOrValue value, Type targetType) { if (targetType.IsValueType) { return new AstCastclassValue(value, targetType); } else { return new AstCastclassRef(value, targetType); } }
/// <summary> /// Initializes a new instance of the <see cref="AstCastclassRef" /> class. /// </summary> /// <param name="value">The value.</param> /// <param name="targetType">The target type.</param> public AstCastclassRef(IAstRefOrValue value, Type targetType) : base(value, targetType) { }
private IAstNode WriteMappingValue( IMappingOperation mappingOperation, int mappingItemId, IAstRefOrValue value) { IAstNode writeValue; if (mappingOperation is SrcReadOperation) { writeValue = AstBuildHelper.CallMethod( typeof(ValueSetter).GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(mappingItemId, typeof(SrcReadOperation)), typeof(SrcReadOperation).GetProperty("Setter") ), (mappingOperation as SrcReadOperation).Setter.GetType() ), new List<IAstStackItem>() { AstBuildHelper.ReadLocalRV(locTo), value, AstBuildHelper.ReadLocalRV(locState), } ); } else { writeValue = AstBuildHelper.WriteMembersChain( (mappingOperation as IDestOperation).Destination.MembersChain, AstBuildHelper.ReadLocalRA(locTo), value ); } return writeValue; }
private IAstNode Process_ValuesFilter( IReadWriteOperation op, int operationId, IAstNode result, IAstRefOrValue value, string fieldName, Delegate filterDelegate ) { result = new AstComplexNode { nodes = new List<IAstNode> { new AstIf { condition = (IAstValue)AstBuildHelper.CallMethod( filterDelegate.GetType().GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(operationId, typeof(IReadWriteOperation)), typeof(IReadWriteOperation).GetProperty(fieldName) ), filterDelegate.GetType() ), new List<IAstStackItem>() { value, AstBuildHelper.ReadLocalRV(locState), } ), trueBranch = new AstComplexNode{ nodes = new List<IAstNode> { result } } } } }; return result; }
public static IAstNode WriteMembersChain(MemberInfo[] membersChain, IAstRefOrAddr targetObject, IAstRefOrValue value) { if (membersChain.Length == 1) { return WriteMember(membersChain[0], targetObject, value); } IAstRefOrAddr readTarget = targetObject; for (int i = 0; i < membersChain.Length - 1; ++i) { readTarget = ReadMemberRA(readTarget, membersChain[i]); } return WriteMember(membersChain[membersChain.Length - 1], readTarget, value); }
public AstWriteLocal(LocalBuilder loc, IAstRefOrValue value) { localIndex = loc.LocalIndex; localType = loc.LocalType; this.value = value; }
public static IAstRefOrValue Convert( Type destinationType, Type sourceType, IAstRefOrValue sourceValue ) { if (destinationType == sourceValue.itemType) { return(sourceValue); } if (destinationType == typeof(string)) { return (new AstCallMethodRef( typeof(NativeConverter).GetMethod( "ObjectToString", BindingFlags.NonPublic | BindingFlags.Static ), null, new List <IAstStackItem>() { sourceValue } )); } foreach (var m in typeof(Convert).GetMethods(BindingFlags.Static | BindingFlags.Public)) { if (m.ReturnType == destinationType) { var parameters = m.GetParameters(); if (parameters.Length == 1 && parameters[0].ParameterType == sourceType) { return (AstBuildHelper.CallMethod( m, null, new List <IAstStackItem> { sourceValue } )); } } } return(AstBuildHelper.CallMethod( typeof(EMConvert).GetMethod( "ChangeType", new[] { typeof(object), typeof(Type), typeof(Type) } ), null, new List <IAstStackItem> { sourceValue, new AstTypeof() { type = sourceType }, new AstTypeof() { type = destinationType } } )); }
public static IAstNode WriteMembersChain(MemberInfo[] membersChain, IAstRefOrAddr targetObject, IAstRefOrValue value) { if (membersChain.Length == 1) { return(WriteMember(membersChain[0], targetObject, value)); } IAstRefOrAddr readTarget = targetObject; for (int i = 0; i < membersChain.Length - 1; ++i) { readTarget = ReadMemberRA(readTarget, membersChain[i]); } return(WriteMember(membersChain[membersChain.Length - 1], readTarget, value)); }
public AstCastclass(IAstRefOrValue value, Type targetType) { _value = value; _targetType = targetType; }
public AstCastclassValue(IAstRefOrValue value, Type targetType): base(value, targetType) { }
public AstWriteArgument(int argumentIndex, Type argumentType, IAstRefOrValue value) { this.argumentIndex = argumentIndex; this.argumentType = argumentType; this.value = value; }
private IAstRefOrValue ConvertMappingValue( ReadWriteSimple rwMapOp, int operationId, IAstRefOrValue sourceValue) { IAstRefOrValue convertedValue = sourceValue; if (rwMapOp.Converter != null) { convertedValue = AstBuildHelper.CallMethod( rwMapOp.Converter.GetType().GetMethod("Invoke"), new AstCastclassRef( (IAstRef)AstBuildHelper.ReadMemberRV( GetStoredObject(operationId, typeof(ReadWriteSimple)), typeof(ReadWriteSimple).GetProperty("Converter") ), rwMapOp.Converter.GetType() ), new List<IAstStackItem>() { sourceValue, AstBuildHelper.ReadLocalRV(locState), } ); } else { if (rwMapOp.ShallowCopy && rwMapOp.Destination.MemberType == rwMapOp.Source.MemberType) { convertedValue = sourceValue; } else { var mi = staticConvertersManager.GetStaticConverter(rwMapOp.Source.MemberType, rwMapOp.Destination.MemberType); if (mi != null) { convertedValue = AstBuildHelper.CallMethod( mi, null, new List<IAstStackItem> { sourceValue } ); } else { convertedValue = ConvertByMapper(rwMapOp); } } } return convertedValue; }
public static IAstNode WriteMember(MemberInfo memberInfo, IAstRefOrAddr targetObject, IAstRefOrValue value) { if (memberInfo.MemberType == MemberTypes.Field) { return new AstWriteField() { fieldInfo = (FieldInfo)memberInfo, targetObject = targetObject, value = value }; } else { return new AstWriteProperty(targetObject, value, (PropertyInfo)memberInfo); } }