Expression Value(IParser parser, Expression valueType, RuntimeSchema schema)
{
Debug.Assert(schema.HasValue);
if (parser.IsBonded || (untaggedWriter && schema.IsBonded))
{
return(parser.Bonded(value =>
writer.WriteBonded(PrunedExpression.Convert(value, typeof(IBonded)))));
}
if (schema.IsStruct)
{
return(GenerateSerialize(Struct, parser, schema));
}
if (schema.IsMap)
{
return(GenerateSerialize(Map, parser, schema));
}
if (schema.IsContainer)
{
return(GenerateSerialize(Container, parser, schema));
}
return(parser.Scalar(valueType, schema.TypeDef.id,
value => writer.Write(value, schema.TypeDef.id)));
}
Expression Value(IParser parser, Expression valueType)
{
if (parser.IsBonded)
{
return(parser.Bonded(value =>
writer.WriteBonded(PrunedExpression.Convert(value, typeof(IBonded)))));
}
var switchCases = new List <DeferredSwitchCase>
{
PrunedExpression.SwitchCase(
() => GenerateSerialize(Container, parser),
BondDataType.BT_LIST,
BondDataType.BT_SET),
PrunedExpression.SwitchCase(
() => GenerateSerialize(Map, parser),
BondDataType.BT_MAP),
PrunedExpression.SwitchCase(
() => GenerateSerialize(Struct, parser),
BondDataType.BT_STRUCT)
};
switchCases.AddRange(
from type in new[]
{
BondDataType.BT_BOOL,
BondDataType.BT_UINT8,
BondDataType.BT_UINT16,
BondDataType.BT_UINT32,
BondDataType.BT_UINT64,
BondDataType.BT_FLOAT,
BondDataType.BT_DOUBLE,
BondDataType.BT_STRING,
BondDataType.BT_INT8,
BondDataType.BT_INT16,
BondDataType.BT_INT32,
BondDataType.BT_INT64,
BondDataType.BT_WSTRING
}
select
PrunedExpression.SwitchCase(
() => parser.Scalar(Expression.Constant(type), type,
value => writer.Write(value, type)),
type));
return(PrunedExpression.Switch(
valueType,
ThrowExpression.InvalidTypeException(valueType),
switchCases));
}
public Expression Assign(Expression left, Expression right)
{
var leftType = left.Type;
if (leftType != right.Type &&
leftType.IsGenericType() &&
leftType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
leftType = leftType.GetTypeInfo().GenericTypeArguments[0];
}
var value = Convert(right, leftType);
return(Expression.Assign(left, PrunedExpression.Convert(value, left.Type)));
}
Expression Value(IParser parser, Expression var, Expression valueType, Type schemaType, bool initialize)
{
if (schemaType.IsBondNullable())
{
return(Nullable(parser, var, schemaType.GetValueType(), initialize));
}
if (schemaType.IsBonded())
{
return(parser.Bonded(value => Expression.Assign(var,
newBonded(var.Type, schemaType, PrunedExpression.Convert(value, typeof(IBonded))))));
}
if (schemaType.IsBondStruct())
{
if (parser.IsBonded)
{
var deserialize = bondedDeserialize.MakeGenericMethod(schemaType);
return(parser.Bonded(value => Expression.Assign(var, Expression.Call(value, deserialize))));
}
return(Deserialize(parser, var, var.Type, schemaType, initialize));
}
if (schemaType.IsBondMap())
{
return(Map(parser, var, schemaType, initialize));
}
if (schemaType.IsBondContainer())
{
return(Container(parser, var, schemaType, initialize));
}
return(parser.Scalar(valueType, schemaType.GetBondDataType(),
value => typeAlias.Assign(var, PrunedExpression.Convert(value, schemaType))));
}