public Cache(Type type)
{
Metadata = GetMetadata(type);
Fields = GetFields(type);
// ReSharper disable once UseObjectOrCollectionInitializer
// The schema field must be instantiated before GetStructDef is called
Schema = new SchemaDef();
Schema.root.struct_def = GetStructDef(type, Metadata, Fields);
}
private static void CreateWriterBody(SchemaDef def, ILGenerator il)
{
il.Emit(OpCodes.Ret);
}
public override bool ApplyEvent(IEvent @event)
{
var previousSchema = SchemaDef;
switch (@event)
{
case SchemaCreated e:
{
Id = e.SchemaId.Id;
SchemaDef = e.Schema;
SchemaFieldsTotal = e.Schema.MaxId();
AppId = e.AppId;
return(true);
}
case FieldAdded e:
{
if (e.ParentFieldId != null)
{
var field = e.Properties.CreateNestedField(e.FieldId.Id, e.Name);
SchemaDef = SchemaDef.UpdateField(e.ParentFieldId.Id, x => ((ArrayField)x).AddField(field));
}
else
{
var partitioning = Partitioning.FromString(e.Partitioning);
var field = e.Properties.CreateRootField(e.FieldId.Id, e.Name, partitioning);
SchemaDef = SchemaDef.DeleteField(e.FieldId.Id);
SchemaDef = SchemaDef.AddField(field);
}
SchemaFieldsTotal = Math.Max(SchemaFieldsTotal, e.FieldId.Id);
break;
}
case SchemaUIFieldsConfigured e:
{
if (e.FieldsInLists != null)
{
SchemaDef = SchemaDef.SetFieldsInLists(e.FieldsInLists);
}
if (e.FieldsInReferences != null)
{
SchemaDef = SchemaDef.SetFieldsInReferences(e.FieldsInReferences);
}
break;
}
case SchemaCategoryChanged e:
{
SchemaDef = SchemaDef.ChangeCategory(e.Name);
break;
}
case SchemaPreviewUrlsConfigured e:
{
SchemaDef = SchemaDef.SetPreviewUrls(e.PreviewUrls);
break;
}
case SchemaScriptsConfigured e:
{
SchemaDef = SchemaDef.SetScripts(e.Scripts);
break;
}
case SchemaFieldRulesConfigured e:
{
SchemaDef = SchemaDef.SetFieldRules(e.FieldRules);
break;
}
case SchemaPublished:
{
SchemaDef = SchemaDef.Publish();
break;
}
case SchemaUnpublished:
{
SchemaDef = SchemaDef.Unpublish();
break;
}
case SchemaUpdated e:
{
SchemaDef = SchemaDef.Update(e.Properties);
break;
}
case SchemaFieldsReordered e:
{
SchemaDef = SchemaDef.ReorderFields(e.FieldIds.ToList(), e.ParentFieldId?.Id);
break;
}
case FieldUpdated e:
{
SchemaDef = SchemaDef.UpdateField(e.FieldId.Id, e.Properties, e.ParentFieldId?.Id);
break;
}
case FieldLocked e:
{
SchemaDef = SchemaDef.LockField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case FieldDisabled e:
{
SchemaDef = SchemaDef.DisableField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case FieldEnabled e:
{
SchemaDef = SchemaDef.EnableField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case FieldHidden e:
{
SchemaDef = SchemaDef.HideField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case FieldShown e:
{
SchemaDef = SchemaDef.ShowField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case FieldDeleted e:
{
SchemaDef = SchemaDef.DeleteField(e.FieldId.Id, e.ParentFieldId?.Id);
break;
}
case SchemaDeleted:
{
IsDeleted = true;
return(true);
}
}
return(!ReferenceEquals(previousSchema, SchemaDef));
}
public static void ToFile(SchemaDef schema, string flatBuffersCodePath, string path)
{
File.WriteAllText(path, ToString(schema, flatBuffersCodePath), Encoding.UTF8);
}
protected void On(SchemaUpdated @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.Update(@event.Properties);
}
protected void On(FieldShown @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.ShowField(@event.FieldId.Id, @event.ParentFieldId?.Id);
}
/// <summary>
/// Add an item to a Store request.
/// </summary>
/// <param name="schemaDef">SchemaDef representing the value(s) to store.</param>
/// <param name="values">One or more values to record in this item.</param>
/// <exception cref="InvalidOperationException">Attempted to add store item in Fetch mode.</exception>
public void AddStoreItem(SchemaDef schemaDef, params string[] values)
{
AddStoreItem(schemaDef.Uri, schemaDef.Alias, values);
}
protected void On(FieldUpdated @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.UpdateField(@event.FieldId.Id, @event.Properties, @event.ParentFieldId?.Id);
}
public static void ToFile(SchemaDef schema, string path)
{
File.WriteAllText(path, ToString(schema), Encoding.UTF8);
}
/// <summary>
/// Add an item to a Fetch request.
/// </summary>
/// <param name="schemaDef">The schema definition for this item.</param>
/// <param name="count">The number of values to return, if more than one value is recorded at the OpenID Provider.</param>
/// <param name="required">Whether or not a response for this item is required.</param>
/// <exception cref="InvalidOperationException">Attempted to add fetch item when it Store mode.</exception>
public void AddFetchItem(SchemaDef schemaDef, int count, bool required)
{
AddFetchItem(schemaDef.Uri, schemaDef.Alias, count, required);
}
private static bool IsUnionType(Type type, SchemaDef schema)
{
return(schema.Unions.Exists(u => u.UnionType == type));
}
private static void AddDeserializeMethod(StringBuilder builder, TableDef table, SchemaDef schema)
{
var tableName = table.Type.FullName;
var fbObjectName = ConvertTypeName(table.Type);
var unionFields = new List <Tuple <FieldDef, UnionDef> >();
builder.AppendLine($@" public override {tableName} Deserialize({fbObjectName} obj)
{{
return new {tableName}()
{{");
foreach (var f in table.Fields)
{
if (IsCollectionType(f.Type))
{
var elementType = GetElementType(f.Type);
if (elementType == typeof(string) || IsScalarType(elementType))
{
builder.Append($" {f.Name} = DeserializeScalar<{elementType.FullName}>(obj.{f.Name}Length, obj.{f.Name})");
}
else if (IsEnumType(elementType))
{
var toArray = IsArrayType(f.Type) ? ".ToArray()" : "";
var enumName = ConvertEnumName(elementType);
var underlyingTypeName = Enum.GetUnderlyingType(elementType).FullName;
builder.Append($" {f.Name} = DeserializeScalar(obj.{f.Name}Length, obj.{f.Name}).Select(e => ({enumName})({underlyingTypeName})e){toArray}");
}
else if (IsUnionType(elementType, schema))
{
var unionSerializerName = $"{ConvertTypeName(elementType)}__UnionSerializer";
builder.Append($" {f.Name} = {unionSerializerName}.Deserialize(obj.{f.Name}Length, obj.{f.Name})");
}
else
{
var elementSerializerName = ConvertSerializerName(elementType);
builder.Append($" {f.Name} = {elementSerializerName}.Instance.Deserialize(obj.{f.Name}Length, obj.{f.Name})");
}
if (IsListType(f.Type))
{
builder.Append(".ToList()");
}
builder.AppendLine(",");
}
else
{
if (f.Type == typeof(string) || IsScalarType(f.Type))
{
builder.AppendLine($" {f.Name} = obj.{f.Name},");
}
else if (IsEnumType(f.Type))
{
var enumName = ConvertEnumName(f.Type);
var underlyingTypeName = Enum.GetUnderlyingType(f.Type).FullName;
builder.AppendLine($" {f.Name} = ({enumName})({underlyingTypeName})obj.{f.Name},");
}
else if (IsUnionType(f.Type, schema))
{
var union = schema.Unions.Find(u => u.UnionType == f.Type);
unionFields.Add(Tuple.Create(f, union));
builder.AppendLine($" {f.Name} = Deserialize{f.Name}(obj),");
}
else
{
var fieldSerializerName = ConvertSerializerName(f.Type);
builder.AppendLine($" {f.Name} = {fieldSerializerName}.Instance.Deserialize(obj.{f.Name}),");
}
}
}
builder.AppendLine(" };");
builder.AppendLine(" }");
foreach (var f in unionFields)
{
AddDeserializeUnionMethod(builder, table, f.Item1, f.Item2);
}
}
private static void AddSerializeMethod(StringBuilder builder, TableDef table, SchemaDef schema)
{
var tableName = table.Type.FullName;
var fbObjectName = ConvertTypeName(table.Type);
builder.AppendLine($@" public override Offset<{fbObjectName}>? Serialize(FlatBufferBuilder fbb, {tableName} obj)
{{
if (obj == null)
return null;");
foreach (var f in table.Fields)
{
if (IsCollectionType(f.Type))
{
var elementType = GetElementType(f.Type);
var toArray = IsListType(f.Type) ? ".ToArray()" : "";
if (elementType == typeof(string))
{
builder.AppendLine($@" var vector{f.Name} = default(VectorOffset?);
if (obj.{f.Name} != null)
{{
var offsets{f.Name} = SerializeString(fbb, obj.{f.Name}{toArray});
vector{f.Name} = {fbObjectName}.Create{f.Name}Vector(fbb, offsets{f.Name});
}}");
}
else if (IsScalarType(elementType))
{
builder.AppendLine($@" var vector{f.Name} = default(VectorOffset?);
if (obj.{f.Name} != null)
vector{f.Name} = {fbObjectName}.Create{f.Name}Vector(fbb, obj.{f.Name}{toArray});");
}
else if (IsEnumType(elementType))
{
var underlyingTypeName = Enum.GetUnderlyingType(elementType).FullName;
var fbEnumTypeName = ConvertTypeName(elementType);
builder.AppendLine($@" var vector{f.Name} = default(VectorOffset?);
if (obj.{f.Name} != null)
{{
var casted{f.Name} = obj.{f.Name}.Select(e => ({fbEnumTypeName})({underlyingTypeName})e).ToArray();
vector{f.Name} = {fbObjectName}.Create{f.Name}Vector(fbb, casted{f.Name});
}}");
}
else if (IsUnionType(elementType, schema))
{
var unionSerializerName = $"{ConvertTypeName(elementType)}__UnionSerializer";
builder.AppendLine($@" var vector{f.Name} = default(VectorOffset?);
if (obj.{f.Name} != null)
{{
var offsets{f.Name} = {unionSerializerName}.Serialize(fbb, obj.{f.Name});
vector{f.Name} = {fbObjectName}.Create{f.Name}Vector(fbb, offsets{f.Name});
}}");
}
else
{
var elementSerializerName = ConvertSerializerName(elementType);
builder.AppendLine($@" var vector{f.Name} = default(VectorOffset?);
if (obj.{f.Name} != null)
{{
var offsets{f.Name} = {elementSerializerName}.Instance.Serialize(fbb, obj.{f.Name});
vector{f.Name} = {fbObjectName}.Create{f.Name}Vector(fbb, offsets{f.Name});
}}");
}
}
else
{
if (f.Type == typeof(string))
{
builder.AppendLine($@" var offset{f.Name} = default(StringOffset?);
if (!string.IsNullOrEmpty(obj.{f.Name}))
offset{f.Name} = fbb.CreateString(obj.{f.Name});");
}
else if (IsScalarType(f.Type) || IsEnumType(f.Type))
{
// Do nothing
}
else if (IsUnionType(f.Type, schema))
{
var union = schema.Unions.Find(u => u.UnionType == f.Type);
var unionFbName = ConvertTypeName(union.UnionType);
builder.AppendLine($@" int offset{f.Name};
{unionFbName} type{f.Name};
{unionFbName}__UnionSerializer.Serialize(fbb, obj.{f.Name}, out offset{f.Name}, out type{f.Name});");
}
else
{
var fieldSerializerName = ConvertSerializerName(f.Type);
builder.AppendLine($@" var offset{f.Name} = {fieldSerializerName}.Instance.Serialize(fbb, obj.{ f.Name});");
}
}
}
builder.AppendLine($@" {fbObjectName}.Start{fbObjectName}(fbb);");
foreach (var f in table.Fields)
{
if (IsCollectionType(f.Type))
{
builder.AppendLine($@" if (vector{f.Name}.HasValue)
{fbObjectName}.Add{f.Name}(fbb, vector{f.Name}.Value);");
}
else
{
if (f.Type == typeof(string))
{
builder.AppendLine($@" if (offset{f.Name}.HasValue)
{fbObjectName}.Add{f.Name}(fbb, offset{f.Name}.Value);");
}
else if (IsScalarType(f.Type))
{
builder.AppendLine($" {fbObjectName}.Add{f.Name}(fbb, obj.{f.Name});");
}
else if (IsEnumType(f.Type))
{
var underlyingTypeName = Enum.GetUnderlyingType(f.Type).FullName;
var fbEnumTypeName = ConvertTypeName(f.Type);
builder.AppendLine($" {fbObjectName}.Add{f.Name}(fbb, ({fbEnumTypeName})({underlyingTypeName})obj.{f.Name});");
}
else if (IsUnionType(f.Type, schema))
{
var union = schema.Unions.Find(u => u.UnionType == f.Type);
var unionFbName = ConvertTypeName(union.UnionType);
builder.AppendLine($@" if (type{f.Name} != {unionFbName}.NONE)
{{
{fbObjectName}.Add{f.Name}(fbb, offset{f.Name});
{fbObjectName}.Add{f.Name}Type(fbb, type{f.Name});
}}");
}
else
{
builder.AppendLine($@" if (offset{f.Name}.HasValue)
{fbObjectName}.Add{f.Name}(fbb, offset{f.Name}.Value);");
}
}
}
builder.AppendLine($@" return {fbObjectName}.End{fbObjectName}(fbb);");
builder.AppendLine(" }");
}
private static void CreateIdentifier(TypeBuilder builder, SchemaDef def)
{
var pIdentifier = builder.DefineProperty(nameof(ICodec.Identifier), PropertyAttributes.None, typeof(ushort), Array.Empty <Type>());
pIdentifier.SetConstant(def.Options.TypeId);
}
public RuntimeSchema(SchemaDef schema)
: this(schema, schema.root)
{}
private static void CreateReaderBody(SchemaDef def, ILGenerator il)
{
il.Emit(OpCodes.Initobj, def.Type);
il.Emit(OpCodes.Ret);
}
RuntimeSchema(SchemaDef schema, TypeDef type)
{
schemaDef = schema;
typeDef = type;
}
protected void On(FieldHidden @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.HideField(@event.FieldId.Id, @event.ParentFieldId?.Id);
}
public void CodecCompiler_should_create_codec_struct_for_simple_class()
{
var schema = SchemaDef.OfType(typeof(Point));
var codec = CodecCompiler.CreateCodec(schema);
}
protected void On(FieldDeleted @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.DeleteField(@event.FieldId.Id, @event.ParentFieldId?.Id);
}
protected void On(FieldLocked @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.LockField(@event.FieldId.Id);
}
protected void On(SchemaUnpublished @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.Unpublish();
}
protected void On(FieldEnabled @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.EnableField(@event.FieldId.Id);
}
protected void On(SchemaFieldsReordered @event, FieldRegistry registry)
{
SchemaDef = SchemaDef.ReorderFields(@event.FieldIds);
}
private static void GenerateBaseSerializer(StringBuilder builder, SchemaDef schema)
{
builder.AppendLine($@"namespace {schema.Namespace}
{{
using FlatBuffers;
using System;
using System.Collections.Generic;
interface ISerializer
{{
byte[] Serialize(object obj);
object Deserialize(byte[] data);
}}
interface ISerializer<TObject, TFlatBufferObject>
where TFlatBufferObject : struct, IFlatbufferObject
{{
Offset<TFlatBufferObject>? Serialize(FlatBufferBuilder fbb, TObject obj);
Offset<TFlatBufferObject>[] Serialize(FlatBufferBuilder fbb, IList<TObject> objects);
TObject Deserialize(TFlatBufferObject? obj);
TObject Deserialize(TFlatBufferObject obj);
TObject[] Deserialize(int objectsLength, Func<int, TFlatBufferObject?> getObjects);
}}
abstract class Serializer<TObject, TFlatBufferObject> : ISerializer<TObject, TFlatBufferObject>, ISerializer
where TFlatBufferObject : struct, IFlatbufferObject
{{
public byte[] Serialize(object obj)
{{
var fbb = new FlatBufferBuilder(1024);
var offset = Serialize(fbb, (TObject)obj);
if (offset.HasValue)
{{
fbb.Finish(offset.Value.Value);
return fbb.SizedByteArray();
}}
else
return null;
}}
public abstract Offset<TFlatBufferObject>? Serialize(FlatBufferBuilder fbb, TObject obj);
public Offset<TFlatBufferObject>[] Serialize(FlatBufferBuilder fbb, IList<TObject> objects)
{{
if (objects == null)
return null;
var offsets = new Offset<TFlatBufferObject>[objects.Count];
for (int i = 0; i < objects.Count; i++)
{{
var offset = Serialize(fbb, objects[i]);
if (offset.HasValue)
offsets[i] = offset.Value;
}}
return offsets;
}}
public static StringOffset[] SerializeString(FlatBufferBuilder fbb, string[] objects)
{{
if (objects == null)
return null;
var offsets = new StringOffset[objects.Length];
for (int i = 0; i < objects.Length; i++)
offsets[i] = fbb.CreateString(objects[i]);
return offsets;
}}
public object Deserialize(byte[] data)
{{
if (data == null)
return default(TObject);
return Deserialize(GetRootAs(new ByteBuffer(data)));
}}
protected abstract TFlatBufferObject GetRootAs(ByteBuffer buffer);
public TObject Deserialize(TFlatBufferObject? obj)
{{
if (!obj.HasValue)
return default(TObject);
return Deserialize(obj.Value);
}}
public abstract TObject Deserialize(TFlatBufferObject obj);
public TObject[] Deserialize(int objectsLength, Func<int, TFlatBufferObject?> getObjects)
{{
if (objectsLength == 0)
return null;
var objects = new TObject[objectsLength];
for (int i = 0; i < objectsLength; i++)
objects[i] = Deserialize(getObjects(i));
return objects;
}}
public static T[] DeserializeScalar<T>(int objectsLength, Func<int, T> getObjects)
{{
if (objectsLength == 0)
return null;
var objects = new T[objectsLength];
for (int i = 0; i < objectsLength; i++)
objects[i] = getObjects(i);
return objects;
}}
}}
}}");
}
