private (string prepareBlock, string serializeBlock) GetStandardSerializeBlocks(int index, TableMemberModel memberModel)
{
string valueVariableName = $"index{index}Value";
string offsetVariableName = $"index{index}Offset";
string condition = $"if ({valueVariableName} != {CSharpHelpers.GetDefaultValueToken(memberModel)})";
if (memberModel.ItemTypeModel is VectorTypeModel vector && vector.IsMemoryVector)
{
// Memory is a struct and can't be null, and 0-length vectors are valid.
// Therefore, we just need to omit the conditional check entirely.
condition = string.Empty;
}
string prepareBlock =
$@"
var {valueVariableName} = item.{memberModel.PropertyInfo.Name};
int {offsetVariableName} = 0;
{condition}
{{
currentOffset += {CSharpHelpers.GetFullMethodName(ReflectedMethods.SerializationHelpers_GetAlignmentErrorMethod)}(currentOffset, {memberModel.ItemTypeModel.Alignment});
{offsetVariableName} = currentOffset;
vtable.{nameof(VTableBuilder.SetOffset)}({index}, currentOffset - tableStart);
currentOffset += {memberModel.ItemTypeModel.InlineSize};
}}";
string serializeBlock =
$@"
if ({offsetVariableName} != 0)
{{
{this.GetSerializeInvocation(memberModel.ItemTypeModel.ClrType, valueVariableName, offsetVariableName)}
}}";
return(prepareBlock, serializeBlock);
}
private string InvokeGetMaxSizeMethod(RuntimeTypeModel model, string parameter)
{
if (model.SchemaType == FlatBufferSchemaType.String)
{
return($"{CSharpHelpers.GetFullMethodName(ReflectedMethods.SerializationHelpers_GetMaxSizeOfStringMethod)}({parameter})");
}
else
{
return($"{this.MethodNames[model.ClrType]}({parameter})");
}
}
private (string prepareBlock, string serializeBlock) GetUnionSerializeBlocks(int index, TableMemberModel memberModel)
{
UnionTypeModel unionModel = (UnionTypeModel)memberModel.ItemTypeModel;
string valueVariableName = $"index{index}Value";
string discriminatorOffsetVariableName = $"index{index}DiscriminatorOffset";
string valueOffsetVariableName = $"index{index}ValueOffset";
string discriminatorValueVariableName = $"index{index}Discriminator";
string prepareBlock =
$@"
var {valueVariableName} = item.{memberModel.PropertyInfo.Name};
int {discriminatorOffsetVariableName} = 0;
int {valueOffsetVariableName} = 0;
byte {discriminatorValueVariableName} = 0;
if ({valueVariableName} != null && {valueVariableName}.Discriminator != 0)
{{
{discriminatorValueVariableName} = {valueVariableName}.Discriminator;
{discriminatorOffsetVariableName} = currentOffset;
vtable.{nameof(VTableBuilder.SetOffset)}({index}, currentOffset - tableStart);
currentOffset++;
currentOffset += {CSharpHelpers.GetFullMethodName(ReflectedMethods.SerializationHelpers_GetAlignmentErrorMethod)}(currentOffset, sizeof(uint));
{valueOffsetVariableName} = currentOffset;
vtable.{nameof(VTableBuilder.SetOffset)}({index + 1}, currentOffset - tableStart);
currentOffset += sizeof(uint);
}}";
List <string> switchCases = new List <string>();
for (int i = 0; i < unionModel.UnionElementTypeModel.Length; ++i)
{
var elementModel = unionModel.UnionElementTypeModel[i];
var unionIndex = i + 1;
string structAdjustment = string.Empty;
if (elementModel.SchemaType == FlatBufferSchemaType.Struct)
{
// Structs are generally written in-line, with the exception of unions.
// So, we need to do the normal allocate space dance here, since we're writing
// a pointer to a struct.
structAdjustment =
$@"
var writeOffset = context.{nameof(SerializationContext.AllocateSpace)}({elementModel.InlineSize}, {elementModel.Alignment});
writer.{nameof(SpanWriter.WriteUOffset)}(span, {valueOffsetVariableName}, writeOffset, context);
{valueOffsetVariableName} = writeOffset;";
}
string @case =
$@"
case {unionIndex}:
{{
{structAdjustment}
{this.GetSerializeInvocation(elementModel.ClrType, $"{valueVariableName}.Item{unionIndex}", valueOffsetVariableName)}
}}
break;";
switchCases.Add(@case);
}
string serializeBlock =
$@"
if ({discriminatorOffsetVariableName} != 0)
{{
{this.GetSerializeInvocation(typeof(byte), discriminatorValueVariableName, discriminatorOffsetVariableName)}
switch ({discriminatorValueVariableName})
{{
{string.Join("\r\n", switchCases)}
default: throw new InvalidOperationException(""Unexpected"");
}}
}}";
return(prepareBlock, serializeBlock);
}
private (string prepareBlock, string serializeBlock) GetStandardSerializeBlocks(int index, TableMemberModel memberModel)
{
string valueVariableName = $"index{index}Value";
string offsetVariableName = $"index{index}Offset";
string condition = $"if ({valueVariableName} != {CSharpHelpers.GetDefaultValueToken(memberModel)})";
if ((memberModel.ItemTypeModel is VectorTypeModel vector && vector.IsMemoryVector) || memberModel.IsKey)
{
// 1) Memory is a struct and can't be null, and 0-length vectors are valid.
// Therefore, we just need to omit the conditional check entirely.
// 2) For sorted vector keys, we must include the value since some other
// libraries cannot do binary search with omitted keys.
condition = string.Empty;
}
string keyCheckMethodCall = string.Empty;
if (memberModel.IsKey)
{
keyCheckMethodCall = $"{nameof(SortedVectorHelpers)}.{nameof(SortedVectorHelpers.EnsureKeyNonNull)}({valueVariableName});";
}
string prepareBlock =
$@"
var {valueVariableName} = item.{memberModel.PropertyInfo.Name};
int {offsetVariableName} = 0;
{keyCheckMethodCall}
{condition}
{{
currentOffset += {CSharpHelpers.GetFullMethodName(ReflectedMethods.SerializationHelpers_GetAlignmentErrorMethod)}(currentOffset, {memberModel.ItemTypeModel.Alignment});
{offsetVariableName} = currentOffset;
vtable.{nameof(VTableBuilder.SetOffset)}({index}, currentOffset - tableStart);
currentOffset += {memberModel.ItemTypeModel.InlineSize};
}}";
string sortInvocation = string.Empty;
if (memberModel.IsSortedVector)
{
VectorTypeModel vectorModel = (VectorTypeModel)memberModel.ItemTypeModel;
TableTypeModel tableModel = (TableTypeModel)vectorModel.ItemTypeModel;
TableMemberModel keyMember = tableModel.IndexToMemberMap.Single(x => x.Value.PropertyInfo == tableModel.KeyProperty).Value;
var builtInType = BuiltInType.BuiltInTypes[keyMember.ItemTypeModel.ClrType];
string inlineSize = builtInType.TypeModel.SchemaType == FlatBufferSchemaType.Scalar ? builtInType.TypeModel.InlineSize.ToString() : "null";
sortInvocation = $"{nameof(SortedVectorHelpers)}.{nameof(SortedVectorHelpers.SortVector)}(" +
$"span, {offsetVariableName}, {keyMember.Index}, {inlineSize}, {CSharpHelpers.GetCompilableTypeName(builtInType.SpanComparerType)}.Instance);";
}
string serializeBlock =
$@"
if ({offsetVariableName} != 0)
{{
{this.GetSerializeInvocation(memberModel.ItemTypeModel.ClrType, valueVariableName, offsetVariableName)}
{sortInvocation}
}}";
return(prepareBlock, serializeBlock);
}