protected override TypeBinaryExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var expression = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var type = typeCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.TypeEqual(expression, type));
}
protected override unsafe InvocationExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var expression = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var arguments = expressionArrayCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.Invoke(expression, arguments));
}
protected override void EncodeTyped(ref byte *data, LambdaExpression expression)
{
CommonCodec.Encode(ref data, expression.Body);
stringCodec.Encode(ref data, expression.Name);
boolCodec.Encode(ref data, expression.TailCall);
expressionArrayCodec.Encode(ref data, expression.Parameters.Select(x => (Expression)x).ToArray());
}
protected override MemberInitExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var newExpression = (NewExpression)CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var bindings = memberBindingCollectionCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.MemberInit(newExpression, bindings));
}
protected override MemberExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var expression = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var member = memberInfoCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.MakeMemberAccess(expression, member));
}
protected override ListInitExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var newExpression = (NewExpression)CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var initializers = elementInitArrayCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.ListInit(newExpression, initializers));
}
protected override void EncodeTyped(ref byte *data, ConditionalExpression expression)
{
CommonCodec.Encode(ref data, expression.Test);
CommonCodec.Encode(ref data, expression.IfTrue);
CommonCodec.Encode(ref data, expression.IfFalse);
typeCodec.Encode(ref data, expression.Type);
}
protected override void EncodeTyped(ref byte *data, BinaryExpression expression)
{
CommonCodec.Encode(ref data, expression.Left);
CommonCodec.Encode(ref data, expression.Right);
boolCodec.Encode(ref data, expression.IsLiftedToNull);
methodInfoCodec.Encode(ref data, expression.Method);
CommonCodec.Encode(ref data, expression.Conversion);
}
protected override unsafe int CalculateSizeTyped(InvocationExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Expression);
result += expressionArrayCodec.CalculateSize(expression.Arguments.ToArray());
return(result);
}
protected override int CalculateSizeTyped(MemberExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Expression);
result += memberInfoCodec.CalculateSize(expression.Member);
return(result);
}
protected override int CalculateSizeTyped(ListInitExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.NewExpression);
result += elementInitArrayCodec.CalculateSize(expression.Initializers.ToArray());
return(result);
}
protected override int CalculateSizeTyped(MemberInitExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.NewExpression);
result += memberBindingCollectionCodec.CalculateSize(expression.Bindings);
return(result);
}
protected override MethodCallExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var instance = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var method = methodInfoCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var arguments = expressionArrayCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.Call(instance, method, arguments));
}
protected override UnaryExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var operand = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var type = typeCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var method = methodInfoCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.MakeUnary(expressionType, operand, type, method));
}
protected override IndexExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var instance = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var indexer = propertyInfoCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var arguments = expressionArrayCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.MakeIndex(instance, indexer, arguments));
}
protected override int CalculateSizeTyped(TypeBinaryExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Expression);
result += typeCodec.CalculateSize(expression.TypeOperand);
return(result);
}
protected override int CalculateSizeTyped(IndexExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Object);
result += propertyInfoCodec.CalculateSize(expression.Indexer);
result += expressionArrayCodec.CalculateSize(expression.Arguments.ToArray());
return(result);
}
protected override int CalculateSizeTyped(UnaryExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Operand);
result += typeCodec.CalculateSize(expression.Type);
result += methodInfoCodec.CalculateSize(expression.Method);
return(result);
}
protected override ConditionalExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var test = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var ifTrue = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var ifFalse = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var type = typeCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.Condition(test, ifTrue, ifFalse, type));
}
protected override int CalculateSizeTyped(MethodCallExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Object);
result += methodInfoCodec.CalculateSize(expression.Method);
result += expressionArrayCodec.CalculateSize(expression.Arguments.ToArray());
return(result);
}
protected override LambdaExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
//var delegateType = typeCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var body = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var name = stringCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var tailCall = boolCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var parameters = expressionArrayCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds).Select(x => (ParameterExpression)x);
return(Expression.Lambda(/*delegateType, */ body, name, tailCall, parameters));
}
protected override int CalculateSizeTyped(ConditionalExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Test);
result += CommonCodec.CalculateSize(expression.IfTrue);
result += CommonCodec.CalculateSize(expression.IfFalse);
result += typeCodec.CalculateSize(expression.Type);
return(result);
}
protected override int CalculateSizeTyped(LambdaExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Body);
result += stringCodec.CalculateSize(expression.Name);
result += boolCodec.CalculateSize(expression.TailCall);
result += expressionArrayCodec.CalculateSize(expression.Parameters.Select(x => (Expression)x).ToArray());
return(result);
}
protected override BinaryExpression DecodeTyped(ExpressionType expressionType, ref byte *data, ref int remainingBytes, bool doNotCheckBounds)
{
var left = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var right = CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var liftToNull = boolCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var method = methodInfoCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
var conversion = (LambdaExpression)CommonCodec.Decode(ref data, ref remainingBytes, doNotCheckBounds);
return(Expression.MakeBinary(expressionType, left, right, liftToNull, method, conversion));
}
protected override int CalculateSizeTyped(BinaryExpression expression)
{
int result = 0;
result += CommonCodec.CalculateSize(expression.Left);
result += CommonCodec.CalculateSize(expression.Right);
result += boolCodec.CalculateSize(expression.IsLiftedToNull);
result += methodInfoCodec.CalculateSize(expression.Method);
result += CommonCodec.CalculateSize(expression.Conversion);
return(result);
}
protected override void EncodeTyped(ref byte *data, IndexExpression expression)
{
CommonCodec.Encode(ref data, expression.Object);
propertyInfoCodec.Encode(ref data, expression.Indexer);
expressionArrayCodec.Encode(ref data, expression.Arguments.ToArray());
}
protected override unsafe void EncodeTyped(ref byte *data, InvocationExpression expression)
{
CommonCodec.Encode(ref data, expression.Expression);
expressionArrayCodec.Encode(ref data, expression.Arguments.ToArray());
}
protected override void EncodeTyped(ref byte *data, MethodCallExpression expression)
{
CommonCodec.Encode(ref data, expression.Object);
methodInfoCodec.Encode(ref data, expression.Method);
expressionArrayCodec.Encode(ref data, expression.Arguments.ToArray());
}
protected override void EncodeTyped(ref byte *data, TypeBinaryExpression expression)
{
CommonCodec.Encode(ref data, expression.Expression);
typeCodec.Encode(ref data, expression.TypeOperand);
}
protected override void EncodeTyped(ref byte *data, UnaryExpression expression)
{
CommonCodec.Encode(ref data, expression.Operand);
typeCodec.Encode(ref data, expression.Type);
methodInfoCodec.Encode(ref data, expression.Method);
}
