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");
}
}
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;
}
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");
}
}
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 AstExprNot(IAstRefOrValue value)
{
_value = value;
}
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);
}
}
public AstExprIsNull(IAstRefOrValue value)
{
this.value = value;
}
public AstWriteLocal(LocalBuilder loc, IAstRefOrValue value)
{
localIndex = loc.LocalIndex;
localType = loc.LocalType;
this.value = value;
}
