public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
Type typeRead;
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64());
typeRead = typeof(long);
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64());
typeRead = typeof(ulong);
}
if (targetType == typeof(object))
{
ilGenerator.Do(pushDescriptor);
if (_signed)
{
ilGenerator.Newobj(() => new DynamicEnum(0L, null));
}
else
{
ilGenerator.Newobj(() => new DynamicEnum(0UL, null));
}
ilGenerator.Castclass(typeof(object));
return;
}
new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, targetType.GetEnumUnderlyingType())(ilGenerator);
}
public static IILGen Call(this IILGen il, Expression <Action> expression)
{
if (expression.Body is NewExpression newExpression)
{
return(il.Call(newExpression.Constructor));
}
var methodInfo = ((MethodCallExpression)expression.Body).Method;
return(il.Call(methodInfo));
}
public void Skip(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).SkipVInt64());
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).SkipVUInt64());
}
}
public static IILGen Call(this IILGen il, Expression <Action> expression)
{
var newExpression = expression.Body as NewExpression;
if (newExpression != null)
{
return(il.Call(newExpression.Constructor));
}
var methodInfo = (expression.Body as MethodCallExpression).Method;
return(il.Call(methodInfo));
}
public static IILGen Call <T>(this IILGen il, Expression <Func <T> > expression)
{
if (expression.Body is MemberExpression memberExpression)
{
return(il.Call(((PropertyInfo)memberExpression.Member).GetGetMethod(true) !));
}
if (expression.Body is NewExpression newExpression)
{
return(il.Call(newExpression.Constructor));
}
var methodInfo = ((MethodCallExpression)expression.Body).Method;
return(il.Call(methodInfo));
}
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
Type typeRead;
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64());
typeRead = typeof(long);
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64());
typeRead = typeof(ulong);
}
new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, _enumType.GetEnumUnderlyingType())(ilGenerator);
}
public void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
Type typeRead;
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64());
typeRead = typeof(long);
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64());
typeRead = typeof(ulong);
}
DefaultTypeConvertorGenerator.Instance.GenerateConversion(typeRead, _enumType.GetEnumUnderlyingType())(ilGenerator);
}
public void GenerateSave(IILGen ilGenerator, Action <IILGen> pushWriter, Action <IILGen> pushCtx, Action <IILGen> pushValue, Type valueType)
{
pushWriter(ilGenerator);
pushValue(ilGenerator);
if (valueType == typeof(byte[]))
{
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(null));
}
else if (valueType == typeof(ByteBuffer))
{
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(ByteBuffer.NewEmpty()));
}
else
{
throw new ArgumentOutOfRangeException(nameof(valueType));
}
}
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).ReadByteArray());
if (targetType == typeof (ByteBuffer))
{
ilGenerator.Call(() => ByteBuffer.NewAsync(null));
return;
}
if (targetType != typeof (object))
{
if (targetType!=typeof(byte[]))
throw new ArgumentOutOfRangeException(nameof(targetType));
return;
}
ilGenerator.Castclass(typeof(object));
}
public static IILGen Call <T>(this IILGen il, Expression <Func <T> > expression)
{
var memberExpression = expression.Body as MemberExpression;
if (memberExpression != null)
{
return(il.Call(((PropertyInfo)memberExpression.Member).GetGetMethod(true)));
}
var newExpression = expression.Body as NewExpression;
if (newExpression != null)
{
return(il.Call(newExpression.Constructor));
}
var methodInfo = (expression.Body as MethodCallExpression).Method;
return(il.Call(methodInfo));
}
public void Skip(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
if (_skipper == null)
{
return;
}
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(_skipper);
}
public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).ReadByteArray());
if (targetType == typeof(ByteBuffer))
{
ilGenerator.Call(() => ByteBuffer.NewAsync(null));
return;
}
if (targetType != typeof(object))
{
if (targetType != typeof(byte[]))
{
throw new ArgumentOutOfRangeException(nameof(targetType));
}
return;
}
ilGenerator.Castclass(typeof(object));
}
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type valueType)
{
pushWriter(ilGenerator);
pushValue(ilGenerator);
if (valueType==typeof(byte[]))
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(null));
else if (valueType==typeof(ByteBuffer))
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(ByteBuffer.NewEmpty()));
else throw new ArgumentOutOfRangeException(nameof(valueType));
}
public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx,
Action <IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
Type typeRead;
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64());
typeRead = typeof(long);
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64());
typeRead = typeof(ulong);
}
if (targetType == typeof(object))
{
ilGenerator.Do(pushDescriptor);
if (_signed)
{
ilGenerator.Newobj(() => new DynamicEnum(0L, null));
}
else
{
ilGenerator.Newobj(() => new DynamicEnum(0UL, null));
}
ilGenerator.Castclass(typeof(object));
return;
}
var trueTargetType = targetType.IsEnum ? targetType.GetEnumUnderlyingType() : targetType;
var conv = _typeSerializers.ConvertorGenerator.GenerateConversion(typeRead, trueTargetType);
if (conv == null)
{
throw new BTDBException("Don't know how to convert from " +
typeRead.ToSimpleName() + " to " + targetType.ToSimpleName());
}
conv(ilGenerator);
}
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
ilGenerator.Call(_loader);
if (targetType != typeof(object))
{
if (targetType != GetPreferedType())
throw new ArgumentOutOfRangeException(nameof(targetType));
return;
}
if (GetPreferedType().IsValueType)
{
ilGenerator.Box(GetPreferedType());
}
else
{
ilGenerator.Castclass(typeof(object));
}
}
public void GenerateLoad(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx, Action <IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
ilGenerator.Call(_loader);
if (targetType != typeof(object))
{
if (targetType != GetPreferedType())
{
throw new ArgumentOutOfRangeException(nameof(targetType));
}
return;
}
if (GetPreferedType().IsValueType)
{
ilGenerator.Box(GetPreferedType());
}
else
{
ilGenerator.Castclass(typeof(object));
}
}
public void GenerateSkip(IILGen ilGenerator, Action <IILGen> pushReader, Action <IILGen> pushCtx)
{
pushReader(ilGenerator);
ilGenerator.Call(_skipper);
}
public static void GenerateJumpIfEqual(IILGen ilGenerator, Type type, IILLabel jumpTo, Action <IILGen> loadLeft, Action <IILGen> loadRight)
{
if (type == typeof(sbyte) || type == typeof(byte) || type == typeof(short) || type == typeof(ushort) ||
type == typeof(int) || type == typeof(uint) || type == typeof(long) || type == typeof(ulong) ||
type == typeof(float) || type == typeof(double) || type == typeof(bool) || type.IsEnum)
{
ilGenerator
.Do(loadLeft)
.Do(loadRight)
.BeqS(jumpTo);
return;
}
if (type.IsGenericType)
{
var genType = type.GetGenericTypeDefinition();
if (genType == typeof(Nullable <>))
{
var localLeft = ilGenerator.DeclareLocal(type, "left");
var localRight = ilGenerator.DeclareLocal(type, "right");
var hasValueMethod = type.GetMethod("get_HasValue");
var getValueMethod = type.GetMethod("GetValueOrDefault", Type.EmptyTypes);
var labelLeftHasValue = ilGenerator.DefineLabel("leftHasValue");
var labelDifferent = ilGenerator.DefineLabel("different");
ilGenerator
.Do(loadLeft)
.Stloc(localLeft)
.Do(loadRight)
.Stloc(localRight)
.Ldloca(localLeft)
.Call(hasValueMethod)
.BrtrueS(labelLeftHasValue)
.Ldloca(localRight)
.Call(hasValueMethod)
.BrtrueS(labelDifferent)
.BrS(jumpTo)
.Mark(labelLeftHasValue)
.Ldloca(localRight)
.Call(hasValueMethod)
.BrfalseS(labelDifferent);
GenerateJumpIfEqual(
ilGenerator,
type.GetGenericArguments()[0],
jumpTo,
g => g.Ldloca(localLeft).Call(getValueMethod),
g => g.Ldloca(localRight).Call(getValueMethod));
ilGenerator.Mark(labelDifferent);
return;
}
}
var equalsMethod = type.GetMethod("Equals", new[] { type, type })
?? type.GetMethod("op_Equality", new[] { type, type });
if (equalsMethod != null)
{
loadLeft(ilGenerator);
loadRight(ilGenerator);
ilGenerator
.Call(equalsMethod)
.BrtrueS(jumpTo);
return;
}
throw new ArgumentOutOfRangeException(nameof(type), $"Don't know how to compare type {type}");
}
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
_fieldHandler.Load(ilGenerator, pushReaderOrCtx);
ilGenerator.Call(() => ByteBuffer.NewAsync(null));
}
public virtual void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(null));
}
public virtual void Skip(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).SkipByteArray());
}
protected virtual void SaveByteBuffer(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(ByteBuffer.NewEmpty()));
}
public virtual void Skip(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).SkipByteArray());
}
public void Skip(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
if (_skipper == null) return;
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(_skipper);
}
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(_saver);
}
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type valueType)
{
pushWriter(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(_saver);
}
public override void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).ReadByteArrayRawTillEof());
}
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType)
{
pushReader(ilGenerator);
Type typeRead;
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64());
typeRead = typeof(long);
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64());
typeRead = typeof(ulong);
}
if (targetType == typeof(object))
{
ilGenerator.Do(pushDescriptor);
if (_signed)
{
ilGenerator.Newobj(() => new DynamicEnum(0L, null));
}
else
{
ilGenerator.Newobj(() => new DynamicEnum(0UL, null));
}
ilGenerator.Castclass(typeof(object));
return;
}
new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, targetType.GetEnumUnderlyingType())(ilGenerator);
}
protected virtual void SaveByteBuffer(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(ByteBuffer.NewEmpty()));
}
public void GenerateSave(IILGen ilGenerator, Action <IILGen> pushWriter, Action <IILGen> pushCtx, Action <IILGen> pushValue, Type valueType)
{
pushWriter(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(_saver);
}
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(_loader);
}
public void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(_loader);
}
public virtual void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(null));
}
public void Save(IILGen ilGenerator, Action <IILGen> pushWriterOrCtx, Action <IILGen> pushValue)
{
pushWriterOrCtx(ilGenerator);
pushValue(ilGenerator);
ilGenerator.Call(_saver);
}
public void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
_fieldHandler.Load(ilGenerator, pushReaderOrCtx);
ilGenerator.Call(() => ByteBuffer.NewAsync(null));
}
public void GenerateSkip(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx)
{
pushReader(ilGenerator);
ilGenerator.Call(_skipper);
}
public void GenerateSkip(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx)
{
pushReader(ilGenerator);
if (_signed)
{
ilGenerator.Call(() => default(AbstractBufferedReader).SkipVInt64());
}
else
{
ilGenerator.Call(() => default(AbstractBufferedReader).SkipVUInt64());
}
}
public override void Load(IILGen ilGenerator, Action <IILGen> pushReaderOrCtx)
{
pushReaderOrCtx(ilGenerator);
ilGenerator.Call(() => default(AbstractBufferedReader).ReadByteArrayRawTillEof());
}
