public override Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
var parser = new SimpleJsonParser <R>(this, Schema.GetElementSchema());
var elementType = Expression.Constant(Schema.TypeDef.element.id);
// if the json contains null instead of an array, simulate an empty list to deserialize a null value
// into a nullable
var readJsonNullAsEmptyList = Expression.Block(
Reader.Read(),
handler(parser, elementType, Expression.Constant(false), Expression.Constant(0), null));
// if the json contains an array, read the array into the list
var readJsonArrayAsList = Expression.Block(
Reader.Read(),
handler(parser, elementType, JsonTokenNotEquals(JsonToken.EndArray), Expression.Constant(0), null),
Reader.Read());
return(Expression.IfThenElse(
JsonTokenEquals(JsonToken.Null),
readJsonNullAsEmptyList,
Expression.IfThenElse(
JsonTokenEquals(JsonToken.StartArray),
readJsonArrayAsList,
ThrowUnexpectedInput("Expected JSON array or null."))));
}
public override Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
return(Items(nextItem => handler(
new SimpleXmlParser <R>(this, Schema.GetElementSchema()),
Expression.Constant(Schema.TypeDef.element.id),
nextItem,
Expression.Constant(0))));
}
public override Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler)
{
return(Items(nextItem => handler(
new SimpleXmlParser <R>(this, Schema.GetKeySchema()),
new SimpleXmlParser <R>(this, Schema.GetElementSchema()),
Expression.Constant(Schema.TypeDef.key.id),
Expression.Constant(Schema.TypeDef.element.id),
nextItem,
nextItem,
Expression.Constant(0))));
}
public override Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler)
{
var keyParser = new SimpleJsonParser <R>(this, Schema.GetKeySchema());
var valueParser = new SimpleJsonParser <R>(this, Schema.GetElementSchema());
var keyType = Expression.Constant(Schema.TypeDef.key.id);
var valueType = Expression.Constant(Schema.TypeDef.element.id);
var next = JsonTokenNotEquals(JsonToken.EndArray);
return(Expression.Block(
Reader.Read(),
handler(keyParser, valueParser, keyType, valueType, next, next, Expression.Constant(0)),
Reader.Read()));
}
public Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler)
{
Debug.Assert(schemaType.IsBondMap());
var itemType = schemaType.GetKeyValueType();
return(EnumerableContainer((item, next, count) => handler(
new ObjectParser(this, Expression.Property(item, "Key"), itemType.Key),
new ObjectParser(this, Expression.Property(item, "Value"), itemType.Value),
Expression.Constant(itemType.Key.GetBondDataType()),
Expression.Constant(itemType.Value.GetBondDataType()),
next,
Expression.Empty(),
count)));
}
public Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler)
{
var count = Expression.Variable(typeof(int), "count");
var keyType = Expression.Variable(typeof(BondDataType), "keyType");
var valueType = Expression.Variable(typeof(BondDataType), "valueType");
var next = Expression.GreaterThan(Expression.PostDecrementAssign(count), Expression.Constant(0));
var loops = MatchOrCompatible(keyType, expectedKeyType, constantKeyType =>
MatchOrCompatible(valueType, expectedValueType, constantValueType =>
handler(this, this, constantKeyType, constantValueType, next, Expression.Empty(), count)));
return(Expression.Block(
new[] { count, keyType, valueType },
reader.ReadContainerBegin(count, keyType, valueType),
loops,
reader.ReadContainerEnd()));
}
public Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
var count = Expression.Variable(typeof(int), "count");
var elementType = Expression.Variable(typeof(BondDataType), "elementType");
var next = Expression.GreaterThan(Expression.PostDecrementAssign(count), Expression.Constant(0));
var loops = MatchOrCompatible(
elementType,
expectedType,
type => handler(this, type, next, count));
return(Expression.Block(
new[] { count, elementType },
reader.ReadContainerBegin(count, elementType),
loops,
reader.ReadContainerEnd()));
}
public Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
Debug.Assert(schema.IsContainer);
var count = Expression.Variable(typeof(int), "count");
var loop = handler(
new UntaggedParser <R>(this, schema.GetElementSchema()),
Expression.Constant(schema.TypeDef.element.id),
Expression.GreaterThan(Expression.PostDecrementAssign(count), Expression.Constant(0)),
count);
return(Expression.Block(
new[] { count },
Expression.Assign(count, reader.ReadContainerBegin()),
loop,
reader.ReadContainerEnd()));
}
public Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
if (schemaType.IsBondNullable())
{
return(Nullable(handler));
}
if (schemaType.IsBondBlob())
{
return(BlobContainer(handler));
}
var itemType = schemaType.GetValueType();
ContainerItemHandler itemHandler = (item, next, count) => handler(
new ObjectParser(this, item, itemType),
Expression.Constant(itemType.GetBondDataType()),
next,
count,
null);
if (value.Type.IsArray)
{
return(ArrayContainer(itemHandler));
}
if (value.Type.IsGenericType())
{
if (typeof(IList <>).MakeGenericType(value.Type.GetTypeInfo().GenericTypeArguments[0]).IsAssignableFrom(value.Type))
{
return(ListContainer(itemHandler));
}
if (typeof(LinkedList <>) == value.Type.GetGenericTypeDefinition())
{
return(LinkedListContainer(itemHandler));
}
}
return(EnumerableContainer(itemHandler));
}
static Expression MatchOrCompatible(Expression valueType, BondDataType?expectedType, TypeHandlerRuntime handler)
{
return((expectedType == null) ?
handler(valueType) :
MatchOrCompatible(valueType, expectedType.Value, type => handler(Expression.Constant(type))));
}
public Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler)
{
throw new System.NotImplementedException();
}
public Expression Container(BondDataType?expectedType, ContainerHandler handler)
{
throw new System.NotImplementedException();
}
public abstract Expression Map(BondDataType?expectedKeyType, BondDataType?expectedValueType, MapHandler handler);
public abstract Expression Container(BondDataType?expectedType, ContainerHandler handler);