Expression Struct(IParser parser, RuntimeSchema schema, bool isBase)
{
var metadata = schema.HasValue ? Expression.Constant(schema.StructDef.metadata) : noMetadata;
var baseSchema = schema.HasBase ? schema.GetBaseSchema() : RuntimeSchema.Empty;
return(parser.Apply(new Transform(
Begin: () => isBase ? writer.WriteBaseBegin(metadata) : writer.WriteStructBegin(metadata),
End: () => isBase ? writer.WriteBaseEnd() : writer.WriteStructEnd(),
Fields: schema.HasValue ?
from field in schema.StructDef.fields
select new Field(
Id: field.id,
Value: (fieldParser, fieldType) =>
Expression.Block(
writer.WriteFieldBegin(fieldType, field.id, field.metadata),
Value(fieldParser, fieldType, schema.GetFieldSchema(field)),
writer.WriteFieldEnd()),
Omitted: () => writer.WriteFieldOmitted(field.type.id, field.id, field.metadata)) :
null,
UnknownField: (fieldParser, fieldType, fieldId) =>
Expression.Block(
writer.WriteFieldBegin(fieldType, fieldId, noMetadata),
Value(fieldParser, fieldType),
writer.WriteFieldEnd()),
Base: baseParser =>
baseSchema.HasValue ? Struct(baseParser, baseSchema, isBase: true) : Expression.Empty(),
UnknownEnd: () => writer.WriteBaseEnd())));
}
protected PullParser(PullParser <T> that, RuntimeSchema schema, bool flatten)
{
Audit.ArgNotNull(that, "that");
Audit.ArgRule(schema.HasValue, "PullParser requires runtime schema");
this.schema = schema;
this.flatten = flatten;
}
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)));
}
UntaggedParser(UntaggedReader <R> reader, DeferredSkip deferredSkip, RuntimeSchema schema)
{
this.reader = reader;
this.schema = schema;
this.deferredSkip = deferredSkip;
hierarchyDepth = schema.GetHierarchyDepth();
}
UntaggedParser(UntaggedReader <R> reader, DeferredSkip deferredSkip, RuntimeSchema schema, PayloadBondedFactory bondedFactory)
{
this.reader = reader;
this.schema = schema;
this.deferredSkip = deferredSkip;
this.bondedFactory = bondedFactory ?? NewBonded;
hierarchyDepth = schema.GetHierarchyDepth();
}
public Deserializer <R> Deserializer <R, T>(RuntimeSchema schema)
{
var parser = schema.HasValue
? ParserFactory <R> .Create(schema, PayloadBondedFactory)
: ParserFactory <R> .Create(typeof(T), PayloadBondedFactory);
return(new Deserializer <R>(typeof(T), parser, Factory, false));
}
Transcoder(RuntimeSchema schema, IParser parser)
{
var serializerTransform = SerializerGeneratorFactory <R, W> .Create(
(r, w, i) => transcode[i](r, w), schema);
var expressions = serializerTransform.Generate(parser);
debugView = DebugViewHelper.ToString(expressions);
}
public Expression Apply(ITransform transform)
{
pairs.Add(new TransformSchemaPair(transform, schema));
if (schema.HasBase)
{
schema = schema.GetBaseSchema();
transform.Base(this);
}
return(Expression.Empty());
}
public Expression Apply(ITransform transform)
{
pairs.Add(new TransformSchemaPair(transform, schema));
if (schema.HasBase)
{
schema = schema.GetBaseSchema();
transform.Base(this);
}
return Expression.Empty();
}
internal static int GetHierarchyDepth(this RuntimeSchema schema)
{
if (!schema.IsStruct)
{
return(0);
}
var depth = 0;
for (var type = schema.TypeDef; type != null; type = schema.SchemaDef.structs[type.struct_def].base_def)
{
depth++;
}
return(depth);
}
Expression Container(IParser parser, RuntimeSchema schema)
{
var expectedValueType = schema.HasValue ? schema.TypeDef.element.id : (BondDataType?)null;
return(parser.Container(expectedValueType,
(valueParser, elementType, next, count) =>
{
var body = ControlExpression.While(next,
Expression.Block(
writer.WriteItemBegin(),
schema.HasValue ?
Value(valueParser, elementType, schema.GetElementSchema()) :
Value(valueParser, elementType),
writer.WriteItemEnd()));
var blob = parser.Blob(count);
if (blob != null)
{
body = PrunedExpression.IfThenElse(
Expression.Equal(elementType, Expression.Constant(BondDataType.BT_INT8)),
writer.WriteBytes(blob),
body);
// For binary protocols we can write blob directly using protocols's WriteBytes
// even if the container is not a blob (blob is BT_LIST of BT_INT8).
if (binaryWriter)
{
body = PrunedExpression.IfThenElse(
Expression.Equal(elementType, Expression.Constant(BondDataType.BT_UINT8)),
writer.WriteBytes(blob),
body);
}
}
return Expression.Block(
writer.WriteContainerBegin(count, elementType),
body,
writer.WriteContainerEnd());
}));
}
static void Main()
{
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output);
// Get runtime schema for type Example and serialize SchemaDef
Serialize.To(writer, Schema <Example> .RuntimeSchema.SchemaDef);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader <InputBuffer>(input);
var schemaDef = Deserialize <SchemaDef> .From(reader);
var schema = new RuntimeSchema(schemaDef);
Debug.Assert(schema.IsStruct);
Debug.Assert(schema.StructDef.metadata.qualified_name == "Examples.Example");
Debug.Assert(schema.StructDef.metadata.attributes["StructAttribute"] == "Value of the attribute");
Debug.Assert(schema.StructDef.fields[0].metadata.attributes["FieldAttribute"] == "Value of the attribute");
Debug.Assert(schema.StructDef.fields[0].type.key.id == BondDataType.BT_UINT32);
Debug.Assert(schema.SchemaDef.structs[1].fields[0].metadata.default_value.string_value == "this is a string");
}
Expression Map(IParser parser, RuntimeSchema schema)
{
var expectedValueType = schema.HasValue ? schema.TypeDef.element.id : (BondDataType?)null;
var expectedKeyType = schema.HasValue ? schema.TypeDef.key.id : (BondDataType?)null;
return(parser.Map(expectedKeyType, expectedValueType,
(keyParser, valueParser, keyType, valueType, nextKey, nextValue, count) =>
Expression.Block(
writer.WriteContainerBegin(count, keyType, valueType),
ControlExpression.While(nextKey,
Expression.Block(
writer.WriteItemBegin(),
schema.HasValue ?
Value(keyParser, keyType, schema.GetKeySchema()) :
Value(keyParser, keyType),
writer.WriteItemEnd(),
nextValue,
writer.WriteItemBegin(),
schema.HasValue ?
Value(valueParser, valueType, schema.GetElementSchema()) :
Value(valueParser, valueType),
writer.WriteItemEnd())),
writer.WriteContainerEnd())));
}
public TestSerializer(Expression <Action <R, W, int> > deferred, RuntimeSchema schema)
{
}
public TaggedParser(RuntimeSchema schema)
{
isBase = false;
baseParser = new TaggedParser <R>(this, isBase: true);
fieldParser = this;
}
protected XmlParser(XmlParser <R> that, RuntimeSchema schema, bool flatten) : base(that, schema, flatten)
{
reader = that.reader;
}
protected XmlParser(RuntimeSchema schema, bool flatten) : base(schema, flatten)
{
}
public TransformSchemaPair(ITransform transform, RuntimeSchema schema)
{
Transform = transform;
Schema = schema;
}
public FlatteningParser(RuntimeSchema rootSchema)
{
schema = rootSchema;
}
public SerializerTransform(Expression <Action <R, W, int> > deferredSerialize, RuntimeSchema schema)
: base(deferredSerialize)
{
runtimeSchema = schema;
}
public TransformSchemaPair(ITransform transform, RuntimeSchema schema)
{
Transform = transform;
Schema = schema;
}
Expression Struct(IParser parser, RuntimeSchema schema)
{
return(Struct(parser, schema, false));
}
public UntaggedParser(RuntimeSchema schema)
: this(new UntaggedReader <R>(), new DeferredSkip(), schema)
{
Audit.ArgRule(schema.HasValue, "UntaggedParser requires runtime schema");
}
UntaggedParser(UntaggedParser <R> that, RuntimeSchema schema)
: this(that.reader, that.deferredSkip, schema, that.bondedFactory)
{
}
public UntaggedParser(RuntimeSchema schema)
: this(schema, null)
{
}
protected SimpleJsonParser(SimpleJsonParser <R> that, RuntimeSchema schema)
: base(that, schema, flatten: true)
{
}
public Transcoder(RuntimeSchema schema)
: this(schema, ParserFactory <R> .Create(schema))
{
}
public SimpleXmlParser(RuntimeSchema schema)
: base(schema, flatten: true)
{
}
Expression GenerateSerialize(SerializeWithSchema serializeWithSchema, IParser parser, RuntimeSchema schema)
{
Debug.Assert(schema.HasValue);
Serialize serialize;
if (!serializeDelegates.TryGetValue(schema, out serialize))
{
serialize = serializeDelegates[schema] = p => serializeWithSchema(p, schema);
}
// Transcoding from tagged protocol with runtime schema generates enormous expression tree
// and for large schemas JIT fails to compile resulting lambda (InvalidProgramException).
// As a workaround we don't inline nested serialize expressions in this case.
var inline = !typeof(ITaggedProtocolReader).IsAssignableFrom(parser.ReaderParam.Type);
inline = inline && (this.inlineNested || !schema.IsStruct);
return(GenerateSerialize(serialize, parser, writer.Param, inline));
}
public UntaggedParser(RuntimeSchema schema, PayloadBondedFactory bondedFactory)
: this(new UntaggedReader <R>(), new DeferredSkip(), schema, bondedFactory)
{
Audit.ArgRule(schema.HasValue, "UntaggedParser requires runtime schema");
}
private SimpleXmlParser(XmlParser <R> that, RuntimeSchema schema)
: base(that, schema, flatten: true)
{
}
public SerializerTransform(Expression <Action <R, W, int> > deferredSerialize, RuntimeSchema schema, bool inlineNested = true)
: base(deferredSerialize)
{
runtimeSchema = schema;
this.inlineNested = inlineNested;
}
public FlatteningParser(RuntimeSchema rootSchema)
{
schema = rootSchema;
}
