BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-02 04:04:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

[C#] Optional Scalars (#6217)

Browse Source 
* [C#] Optional Scalars

* Moved scalar optional check to avoid null enum conversion
This commit is contained in:
Derek Bailey
2020-10-30 13:18:59 -07:00
committed by GitHub
parent 6034de286a
commit ea92a668d8
11 changed files with 758 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
net/FlatBuffers/FlatBufferBuilder.cs
View File

@@ -449,6 +449,15 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddBool(int o, bool x, bool d) { if (ForceDefaults || x != d) { AddBool(x); Slot(o); } }
/// <summary>
/// Adds a Boolean to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable boolean value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddBool(int o, bool? x) { if (x.HasValue) { AddBool(x.Value); Slot(o); } }
/// <summary>
/// Adds a SByte to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -458,6 +467,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddSbyte(int o, sbyte x, sbyte d) { if (ForceDefaults || x != d) { AddSbyte(x); Slot(o); } }
/// <summary>
/// Adds a SByte to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable sbyte value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddSbyte(int o, sbyte? x) { if (x.HasValue) { AddSbyte(x.Value); Slot(o); } }
/// <summary>
/// Adds a Byte to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -467,6 +484,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddByte(int o, byte x, byte d) { if (ForceDefaults || x != d) { AddByte(x); Slot(o); } }
/// <summary>
/// Adds a Byte to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable byte value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddByte(int o, byte? x) { if (x.HasValue) { AddByte(x.Value); Slot(o); } }
/// <summary>
/// Adds a Int16 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -476,6 +501,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddShort(int o, short x, int d) { if (ForceDefaults || x != d) { AddShort(x); Slot(o); } }
/// <summary>
/// Adds a Int16 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable int16 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddShort(int o, short? x) { if (x.HasValue) { AddShort(x.Value); Slot(o); } }
/// <summary>
/// Adds a UInt16 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -485,6 +518,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddUshort(int o, ushort x, ushort d) { if (ForceDefaults || x != d) { AddUshort(x); Slot(o); } }
/// <summary>
/// Adds a Uint16 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable uint16 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddUshort(int o, ushort? x) { if (x.HasValue) { AddUshort(x.Value); Slot(o); } }
/// <summary>
/// Adds an Int32 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -494,6 +535,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddInt(int o, int x, int d) { if (ForceDefaults || x != d) { AddInt(x); Slot(o); } }
/// <summary>
/// Adds a Int32 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable int32 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddInt(int o, int? x) { if (x.HasValue) { AddInt(x.Value); Slot(o); } }
/// <summary>
/// Adds a UInt32 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -503,6 +552,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddUint(int o, uint x, uint d) { if (ForceDefaults || x != d) { AddUint(x); Slot(o); } }
/// <summary>
/// Adds a UInt32 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable uint32 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddUint(int o, uint? x) { if (x.HasValue) { AddUint(x.Value); Slot(o); } }
/// <summary>
/// Adds an Int64 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -512,6 +569,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddLong(int o, long x, long d) { if (ForceDefaults || x != d) { AddLong(x); Slot(o); } }
/// <summary>
/// Adds a Int64 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddLong(int o, long? x) { if (x.HasValue) { AddLong(x.Value); Slot(o); } }
/// <summary>
/// Adds a UInt64 to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -521,6 +586,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddUlong(int o, ulong x, ulong d) { if (ForceDefaults || x != d) { AddUlong(x); Slot(o); } }
/// <summary>
/// Adds a UInt64 to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddUlong(int o, ulong? x) { if (x.HasValue) { AddUlong(x.Value); Slot(o); } }
/// <summary>
/// Adds a Single to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -530,6 +603,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddFloat(int o, float x, double d) { if (ForceDefaults || x != d) { AddFloat(x); Slot(o); } }
/// <summary>
/// Adds a Single to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable single value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddFloat(int o, float? x) { if (x.HasValue) { AddFloat(x.Value); Slot(o); } }
/// <summary>
/// Adds a Double to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>
@@ -539,6 +620,14 @@ namespace FlatBuffers
/// <param name="d">The default value to compare the value against</param>
public void AddDouble(int o, double x, double d) { if (ForceDefaults || x != d) { AddDouble(x); Slot(o); } }
/// <summary>
/// Adds a Double to the Table at index `o` in its vtable using the nullable value `x`
/// </summary>
/// <param name="o">The index into the vtable</param>
/// <param name="x">The nullable double value to put into the buffer. If it doesn't have a value
/// it will skip writing to the buffer.</param>
public void AddDouble(int o, double? x) { if (x.HasValue) { AddDouble(x.Value); Slot(o); } }
/// <summary>
/// Adds a buffer offset to the Table at index `o` in its vtable using the value `x` and default `d`
/// </summary>

35
src/idl_gen_csharp.cpp
View File

@@ -214,6 +214,9 @@ class CSharpGenerator : public BaseGenerator {
std::string GenDefaultValue(const FieldDef &field,
bool enableLangOverrides) const {
// If it is an optional scalar field, the default is null
if (field.IsScalarOptional()) { return "null"; }
auto &value = field.value;
if (enableLangOverrides) {
// handles both enum case and vector of enum case
@@ -396,6 +399,7 @@ class CSharpGenerator : public BaseGenerator {
} else {
code += ", ";
code += GenTypeBasic(type);
if (field.IsScalarOptional()) { code += "?"; }
if (array_cnt > 0) {
code += "[";
for (size_t i = 1; i < array_cnt; i++) code += ",";
@@ -610,6 +614,7 @@ class CSharpGenerator : public BaseGenerator {
optional = "?";
conditional_cast = "(" + type_name_dest + optional + ")";
}
if (field.IsScalarOptional()) { optional = "?"; }
std::string dest_mask = "";
std::string dest_cast = DestinationCast(field.value.type);
std::string src_cast = SourceCast(field.value.type);
@@ -646,9 +651,11 @@ class CSharpGenerator : public BaseGenerator {
// that doesn't need to be casted. However, default values for enum
// elements of vectors are integer literals ("0") and are still casted
// for clarity.
if (field.value.type.enum_def == nullptr ||
IsVector(field.value.type)) {
default_cast = "(" + type_name_dest + ")";
// If the scalar is optional and enum, we still need the cast.
if ((field.value.type.enum_def == nullptr ||
IsVector(field.value.type)) ||
(IsEnum(field.value.type) && field.IsScalarOptional())) {
default_cast = "(" + type_name_dest + optional + ")";
}
}
std::string member_suffix = "; ";
@@ -974,6 +981,7 @@ class CSharpGenerator : public BaseGenerator {
code += " = null";
} else {
code += GenTypeBasic(field.value.type);
if (field.IsScalarOptional()) { code += "?"; }
code += " ";
code += field.name;
if (!IsScalar(field.value.type.base_type)) code += "Offset";
@@ -1034,6 +1042,7 @@ class CSharpGenerator : public BaseGenerator {
code += GenTypeBasic(field.value.type);
auto argname = MakeCamel(field.name, false);
if (!IsScalar(field.value.type.base_type)) argname += "Offset";
if (field.IsScalarOptional()) { code += "?"; }
code += " " + argname + ") { builder.Add";
code += GenMethod(field.value.type) + "(";
code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
@@ -1043,8 +1052,13 @@ class CSharpGenerator : public BaseGenerator {
field.value.type.base_type != BASE_TYPE_UNION) {
code += ".Value";
}
code += ", ";
code += GenDefaultValue(field, false);
if (!field.IsScalarOptional()) {
// When the scalar is optional, use the builder method that doesn't
// supply a default value. Otherwise, we to continue to use the
// default value method.
code += ", ";
code += GenDefaultValue(field, false);
}
code += "); }\n";
if (IsVector(field.value.type)) {
auto vector_type = field.value.type.VectorType();
@@ -1069,7 +1083,7 @@ class CSharpGenerator : public BaseGenerator {
code += SourceCastBasic(vector_type);
code += "data[i]";
if (vector_type.base_type == BASE_TYPE_STRUCT ||
IsString(vector_type))
IsString(vector_type))
code += ".Value";
code += "); return ";
code += "builder.EndVector(); }\n";
@@ -1476,11 +1490,10 @@ class CSharpGenerator : public BaseGenerator {
case BASE_TYPE_ARRAY: {
auto type_name = GenTypeGet_ObjectAPI(field.value.type, opts);
auto length_str = NumToString(field.value.type.fixed_length);
auto unpack_method = field.value.type.struct_def == nullptr
? ""
: field.value.type.struct_def->fixed
? ".UnPack()"
: "?.UnPack()";
auto unpack_method = field.value.type.struct_def == nullptr ? ""
: field.value.type.struct_def->fixed
? ".UnPack()"
: "?.UnPack()";
code += start + "new " + type_name.substr(0, type_name.length() - 1) +
length_str + "];\n";
code += " for (var _j = 0; _j < " + length_str + "; ++_j) { _o." +

15
src/idl_parser.cpp
View File

@@ -716,8 +716,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) {
// with a special suffix.
ECHECK(AddField(struct_def, name + UnionTypeFieldSuffix(),
type.enum_def->underlying_type, &typefield));
} else if (IsVector(type) &&
type.element == BASE_TYPE_UNION) {
} else if (IsVector(type) && type.element == BASE_TYPE_UNION) {
// Only cpp, js and ts supports the union vector feature so far.
if (!SupportsAdvancedUnionFeatures()) {
return Error(
@@ -792,8 +791,8 @@ CheckedError Parser::ParseField(StructDef &struct_def) {
// Table, struct or string can't have enum_def.
// Default value of union and vector in NONE, NULL translated to "0".
FLATBUFFERS_ASSERT(IsInteger(type.base_type) ||
(type.base_type == BASE_TYPE_UNION) ||
IsVector(type) || IsArray(type));
(type.base_type == BASE_TYPE_UNION) || IsVector(type) ||
IsArray(type));
if (IsVector(type)) {
// Vector can't use initialization list.
FLATBUFFERS_ASSERT(field->value.constant == "0");
@@ -814,8 +813,7 @@ CheckedError Parser::ParseField(StructDef &struct_def) {
field->deprecated = field->attributes.Lookup("deprecated") != nullptr;
auto hash_name = field->attributes.Lookup("hash");
if (hash_name) {
switch ((IsVector(type)) ? type.element
: type.base_type) {
switch ((IsVector(type)) ? type.element : type.base_type) {
case BASE_TYPE_SHORT:
case BASE_TYPE_USHORT: {
if (FindHashFunction16(hash_name->constant.c_str()) == nullptr)
@@ -968,8 +966,7 @@ CheckedError Parser::ParseAnyValue(Value &val, FieldDef *field,
auto &type = elem->second->value.type;
if (type.enum_def == val.type.enum_def) {
if (inside_vector) {
if (IsVector(type) &&
type.element == BASE_TYPE_UTYPE) {
if (IsVector(type) && type.element == BASE_TYPE_UTYPE) {
// Vector of union type field.
uoffset_t offset;
ECHECK(atot(elem->first.constant.c_str(), *this, &offset));
@@ -2283,7 +2280,7 @@ bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions &opts) {
static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster |
IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava |
IDLOptions::kTs | IDLOptions::kJs;
IDLOptions::kCSharp | IDLOptions::kTs | IDLOptions::kJs;
unsigned long langs = opts.lang_to_generate;
return (langs > 0 && langs < IDLOptions::kMAX) && !(langs & ~supported_langs);
}

220
tests/FlatBuffers.Test/FlatBufferBuilderTests.cs
View File

@@ -248,6 +248,226 @@ namespace FlatBuffers.Test
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableBool_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddBool(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableSbyte_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddSbyte(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableByte_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddByte(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableShort_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddShort(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableUShort_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUshort(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableInt_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddInt(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableUInt_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUint(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableLong_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddLong(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableULong_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUlong(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableFloat_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddFloat(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableDouble_OffsetIsUnchanged()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddDouble(0, null);
var endOffset = fbb.Offset;
Assert.AreEqual(endOffset, storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableBool_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddBool(0, true);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(bool), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableSbyte_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddSbyte(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(sbyte), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableByte_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddByte(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(byte), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableShort_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddShort(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(short), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableUShort_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUshort(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(ushort), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableInt_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddInt(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(int), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableUInt_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUint(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(uint), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableLong_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddLong(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(long), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableULong_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddUlong(0, 1);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(ulong), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableFloat_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddFloat(0, 1.0F);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(float), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_WhenAddNullableDouble_OffsetIsChangedBySize()
{
var fbb = CreateBuffer(false);
var storedOffset = fbb.Offset;
fbb.AddDouble(0, 1.0);
var endOffset = fbb.Offset;
Assert.AreEqual(sizeof(double), endOffset - storedOffset);
}
[FlatBuffersTestMethod]
public void FlatBufferBuilder_Add_Array_Float()
{

6
tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj
View File

@@ -128,6 +128,12 @@
<Compile Include="..\union_vector\Rapunzel.cs">
<Link>union_vector\Rapunzel.cs</Link>
</Compile>
<Compile Include="..\optional_scalars\OptionalByte.cs">
<Link>optional_scalars\OptionalByte.cs</Link>
</Compile>
<Compile Include="..\optional_scalars\ScalarStuff.cs">
<Link>optional_scalars\ScalarStuff.cs</Link>
</Compile>
</ItemGroup>
<ItemGroup>

6
tests/FlatBuffers.Test/FlatBuffers.Test.csproj
View File

@@ -159,6 +159,12 @@
<Compile Include="..\union_vector\Rapunzel.cs">
<Link>union_vector\Rapunzel.cs</Link>
</Compile>
<Compile Include="..\optional_scalars\OptionalByte.cs">
<Link>optional_scalars\OptionalByte.cs</Link>
</Compile>
<Compile Include="..\optional_scalars\ScalarStuff.cs">
<Link>optional_scalars\ScalarStuff.cs</Link>
</Compile>
<Compile Include="Assert.cs" />
<Compile Include="ByteBufferTests.cs" />
<Compile Include="FlatBufferBuilderTests.cs" />

206
tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
View File

@@ -18,6 +18,7 @@ using System.IO;
using System.Text;
using System.Threading;
using MyGame.Example;
using optional_scalars;
namespace FlatBuffers.Test
{
@@ -891,5 +892,210 @@ namespace FlatBuffers.Test
// Make sure we never read the values incorrectly.
Assert.AreEqual(0, _failures);
}
[FlatBuffersTestMethod]
public void TestScalarOptional_EmptyBuffer() {
var fbb = new FlatBufferBuilder(1);
ScalarStuff.StartScalarStuff(fbb);
var offset = ScalarStuff.EndScalarStuff(fbb);
ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
Assert.AreEqual((sbyte)0, scalarStuff.JustI8);
Assert.AreEqual(null, scalarStuff.MaybeI8);
Assert.AreEqual((sbyte)42, scalarStuff.DefaultI8);
Assert.AreEqual((byte)0, scalarStuff.JustU8);
Assert.AreEqual(null, scalarStuff.MaybeU8);
Assert.AreEqual((byte)42, scalarStuff.DefaultU8);
Assert.AreEqual((short)0, scalarStuff.JustI16);
Assert.AreEqual(null, scalarStuff.MaybeI16);
Assert.AreEqual((short)42, scalarStuff.DefaultI16);
Assert.AreEqual((ushort)0, scalarStuff.JustU16);
Assert.AreEqual(null, scalarStuff.MaybeU16);
Assert.AreEqual((ushort)42, scalarStuff.DefaultU16);
Assert.AreEqual((int)0, scalarStuff.JustI32);
Assert.AreEqual(null, scalarStuff.MaybeI32);
Assert.AreEqual((int)42, scalarStuff.DefaultI32);
Assert.AreEqual((uint)0, scalarStuff.JustU32);
Assert.AreEqual(null, scalarStuff.MaybeU32);
Assert.AreEqual((uint)42, scalarStuff.DefaultU32);
Assert.AreEqual((long)0, scalarStuff.JustI64);
Assert.AreEqual(null, scalarStuff.MaybeI64);
Assert.AreEqual((long)42, scalarStuff.DefaultI64);
Assert.AreEqual((ulong)0, scalarStuff.JustU64);
Assert.AreEqual(null, scalarStuff.MaybeU64);
Assert.AreEqual((ulong)42, scalarStuff.DefaultU64);
Assert.AreEqual((float)0.0F, scalarStuff.JustF32);
Assert.AreEqual(null, scalarStuff.MaybeF32);
Assert.AreEqual((float)42.0F, scalarStuff.DefaultF32);
Assert.AreEqual((double)0.0, scalarStuff.JustF64);
Assert.AreEqual(null, scalarStuff.MaybeF64);
Assert.AreEqual((double)42.0, scalarStuff.DefaultF64);
Assert.AreEqual(false, scalarStuff.JustBool);
Assert.AreEqual(null, scalarStuff.MaybeBool);
Assert.AreEqual(true, scalarStuff.DefaultBool);
Assert.AreEqual(OptionalByte.None, scalarStuff.JustEnum);
Assert.AreEqual(null, scalarStuff.MaybeEnum);
Assert.AreEqual(OptionalByte.One, scalarStuff.DefaultEnum);
}
[FlatBuffersTestMethod]
public void TestScalarOptional_Construction() {
var fbb = new FlatBufferBuilder(1);
ScalarStuff.StartScalarStuff(fbb);
ScalarStuff.AddJustI8(fbb, 5);
ScalarStuff.AddMaybeI8(fbb, 5);
ScalarStuff.AddDefaultI8(fbb, 5);
ScalarStuff.AddJustU8(fbb, 6);
ScalarStuff.AddMaybeU8(fbb, 6);
ScalarStuff.AddDefaultU8(fbb, 6);
ScalarStuff.AddJustI16(fbb, 7);
ScalarStuff.AddMaybeI16(fbb, 7);
ScalarStuff.AddDefaultI16(fbb, 7);
ScalarStuff.AddJustU16(fbb, 8);
ScalarStuff.AddMaybeU16(fbb, 8);
ScalarStuff.AddDefaultU16(fbb, 8);
ScalarStuff.AddJustI32(fbb, 9);
ScalarStuff.AddMaybeI32(fbb, 9);
ScalarStuff.AddDefaultI32(fbb, 9);
ScalarStuff.AddJustU32(fbb, 10);
ScalarStuff.AddMaybeU32(fbb, 10);
ScalarStuff.AddDefaultU32(fbb, 10);
ScalarStuff.AddJustI64(fbb, 11);
ScalarStuff.AddMaybeI64(fbb, 11);
ScalarStuff.AddDefaultI64(fbb, 11);
ScalarStuff.AddJustU64(fbb, 12);
ScalarStuff.AddMaybeU64(fbb, 12);
ScalarStuff.AddDefaultU64(fbb, 12);
ScalarStuff.AddJustF32(fbb, 13.0f);
ScalarStuff.AddMaybeF32(fbb, 13.0f);
ScalarStuff.AddDefaultF32(fbb, 13.0f);
ScalarStuff.AddJustF64(fbb, 14.0);
ScalarStuff.AddMaybeF64(fbb, 14.0);
ScalarStuff.AddDefaultF64(fbb, 14.0);
ScalarStuff.AddJustBool(fbb, true);
ScalarStuff.AddMaybeBool(fbb, true);
ScalarStuff.AddDefaultBool(fbb, false); // note this is the opposite
ScalarStuff.AddJustEnum(fbb, OptionalByte.Two);
ScalarStuff.AddMaybeEnum(fbb, OptionalByte.Two);
ScalarStuff.AddDefaultEnum(fbb, OptionalByte.Two);
var offset = ScalarStuff.EndScalarStuff(fbb);
ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
Assert.AreEqual((sbyte)5, scalarStuff.JustI8);
Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8);
Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8);
Assert.AreEqual((byte)6, scalarStuff.JustU8);
Assert.AreEqual((byte)6, scalarStuff.MaybeU8);
Assert.AreEqual((byte)6, scalarStuff.DefaultU8);
Assert.AreEqual((short)7, scalarStuff.JustI16);
Assert.AreEqual((short)7, scalarStuff.MaybeI16);
Assert.AreEqual((short)7, scalarStuff.DefaultI16);
Assert.AreEqual((ushort)8, scalarStuff.JustU16);
Assert.AreEqual((ushort)8, scalarStuff.MaybeU16);
Assert.AreEqual((ushort)8, scalarStuff.DefaultU16);
Assert.AreEqual((int)9, scalarStuff.JustI32);
Assert.AreEqual((int)9, scalarStuff.MaybeI32);
Assert.AreEqual((int)9, scalarStuff.DefaultI32);
Assert.AreEqual((uint)10, scalarStuff.JustU32);
Assert.AreEqual((uint)10, scalarStuff.MaybeU32);
Assert.AreEqual((uint)10, scalarStuff.DefaultU32);
Assert.AreEqual((long)11, scalarStuff.JustI64);
Assert.AreEqual((long)11, scalarStuff.MaybeI64);
Assert.AreEqual((long)11, scalarStuff.DefaultI64);
Assert.AreEqual((ulong)12, scalarStuff.JustU64);
Assert.AreEqual((ulong)12, scalarStuff.MaybeU64);
Assert.AreEqual((ulong)12, scalarStuff.DefaultU64);
Assert.AreEqual((float)13.0F, scalarStuff.JustF32);
Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32);
Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32);
Assert.AreEqual((double)14.0, scalarStuff.JustF64);
Assert.AreEqual((double)14.0, scalarStuff.MaybeF64);
Assert.AreEqual((double)14.0, scalarStuff.DefaultF64);
Assert.AreEqual(true, scalarStuff.JustBool);
Assert.AreEqual(true, scalarStuff.MaybeBool);
Assert.AreEqual(false, scalarStuff.DefaultBool);
Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum);
Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum);
Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum);
}
[FlatBuffersTestMethod]
public void TestScalarOptional_Construction_CreatorMethod() {
var fbb = new FlatBufferBuilder(1);
var offset = ScalarStuff.CreateScalarStuff(fbb,5,5,5,6,6,6,7,7,7,
8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13.0f,13.0f,13.0f,14.0,
14.0,14.0,true,true,false,OptionalByte.Two,OptionalByte.Two,
OptionalByte.Two);
ScalarStuff.FinishScalarStuffBuffer(fbb, offset);
ScalarStuff scalarStuff = ScalarStuff.GetRootAsScalarStuff(fbb.DataBuffer);
Assert.AreEqual((sbyte)5, scalarStuff.JustI8);
Assert.AreEqual((sbyte)5, scalarStuff.MaybeI8);
Assert.AreEqual((sbyte)5, scalarStuff.DefaultI8);
Assert.AreEqual((byte)6, scalarStuff.JustU8);
Assert.AreEqual((byte)6, scalarStuff.MaybeU8);
Assert.AreEqual((byte)6, scalarStuff.DefaultU8);
Assert.AreEqual((short)7, scalarStuff.JustI16);
Assert.AreEqual((short)7, scalarStuff.MaybeI16);
Assert.AreEqual((short)7, scalarStuff.DefaultI16);
Assert.AreEqual((ushort)8, scalarStuff.JustU16);
Assert.AreEqual((ushort)8, scalarStuff.MaybeU16);
Assert.AreEqual((ushort)8, scalarStuff.DefaultU16);
Assert.AreEqual((int)9, scalarStuff.JustI32);
Assert.AreEqual((int)9, scalarStuff.MaybeI32);
Assert.AreEqual((int)9, scalarStuff.DefaultI32);
Assert.AreEqual((uint)10, scalarStuff.JustU32);
Assert.AreEqual((uint)10, scalarStuff.MaybeU32);
Assert.AreEqual((uint)10, scalarStuff.DefaultU32);
Assert.AreEqual((long)11, scalarStuff.JustI64);
Assert.AreEqual((long)11, scalarStuff.MaybeI64);
Assert.AreEqual((long)11, scalarStuff.DefaultI64);
Assert.AreEqual((ulong)12, scalarStuff.JustU64);
Assert.AreEqual((ulong)12, scalarStuff.MaybeU64);
Assert.AreEqual((ulong)12, scalarStuff.DefaultU64);
Assert.AreEqual((float)13.0F, scalarStuff.JustF32);
Assert.AreEqual((float)13.0F, scalarStuff.MaybeF32);
Assert.AreEqual((float)13.0F, scalarStuff.DefaultF32);
Assert.AreEqual((double)14.0, scalarStuff.JustF64);
Assert.AreEqual((double)14.0, scalarStuff.MaybeF64);
Assert.AreEqual((double)14.0, scalarStuff.DefaultF64);
Assert.AreEqual(true, scalarStuff.JustBool);
Assert.AreEqual(true, scalarStuff.MaybeBool);
Assert.AreEqual(false, scalarStuff.DefaultBool);
Assert.AreEqual(OptionalByte.Two, scalarStuff.JustEnum);
Assert.AreEqual(OptionalByte.Two, scalarStuff.MaybeEnum);
Assert.AreEqual(OptionalByte.Two, scalarStuff.DefaultEnum);
}
}
}

2
tests/generate_code.bat
View File

@@ -55,7 +55,7 @@ set TEST_NOINCL_FLAGS=%TEST_BASE_FLAGS% --no-includes --no-fb-import
..\%buildtype%\flatc.exe --cpp %TEST_BASE_FLAGS% --cpp-ptr-type flatbuffers::unique_ptr native_type_test.fbs || goto FAIL
@rem Generate the optional scalar code for tests.
..\%buildtype%\flatc.exe --kotlin --rust --lobster --ts --js optional_scalars.fbs || goto FAIL
..\%buildtype%\flatc.exe --csharp --java --kotlin --rust --lobster --ts --js optional_scalars.fbs || goto FAIL
..\%buildtype%\flatc.exe %TEST_NOINCL_FLAGS% %TEST_CPP_FLAGS% --cpp optional_scalars.fbs || goto FAIL
@rem Generate the schema evolution tests

2
tests/generate_code.sh
View File

@@ -53,7 +53,7 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace
../flatc --dart monster_extra.fbs
# Generate optional scalar code for tests.
../flatc --java --kotlin --rust --lobster --ts --js optional_scalars.fbs
../flatc --csharp --java --kotlin --rust --lobster --ts --js optional_scalars.fbs
../flatc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --cpp optional_scalars.fbs
# Generate the schema evolution tests

16
tests/optional_scalars/OptionalByte.cs Normal file
View File

@@ -0,0 +1,16 @@
// <auto-generated>
// automatically generated by the FlatBuffers compiler, do not modify
// </auto-generated>
namespace optional_scalars
{
public enum OptionalByte : sbyte
{
None = 0,
One = 1,
Two = 2,
};
}

183
tests/optional_scalars/ScalarStuff.cs Normal file
View File

@@ -0,0 +1,183 @@
// <auto-generated>
// automatically generated by the FlatBuffers compiler, do not modify
// </auto-generated>
namespace optional_scalars
{
using global::System;
using global::System.Collections.Generic;
using global::FlatBuffers;
public struct ScalarStuff : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb) { return GetRootAsScalarStuff(_bb, new ScalarStuff()); }
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "NULL"); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
public sbyte JustI8 { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte)0; } }
public sbyte? MaybeI8 { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte?)null; } }
public sbyte DefaultI8 { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte)42; } }
public byte JustU8 { get { int o = __p.__offset(10); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
public byte? MaybeU8 { get { int o = __p.__offset(12); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
public byte DefaultU8 { get { int o = __p.__offset(14); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)42; } }
public short JustI16 { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short)0; } }
public short? MaybeI16 { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short?)null; } }
public short DefaultI16 { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short)42; } }
public ushort JustU16 { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } }
public ushort? MaybeU16 { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort?)null; } }
public ushort DefaultU16 { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)42; } }
public int JustI32 { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
public int? MaybeI32 { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int?)null; } }
public int DefaultI32 { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)42; } }
public uint JustU32 { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
public uint? MaybeU32 { get { int o = __p.__offset(36); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint?)null; } }
public uint DefaultU32 { get { int o = __p.__offset(38); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)42; } }
public long JustI64 { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
public long? MaybeI64 { get { int o = __p.__offset(42); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long?)null; } }
public long DefaultI64 { get { int o = __p.__offset(44); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)42; } }
public ulong JustU64 { get { int o = __p.__offset(46); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)0; } }
public ulong? MaybeU64 { get { int o = __p.__offset(48); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong?)null; } }
public ulong DefaultU64 { get { int o = __p.__offset(50); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)42; } }
public float JustF32 { get { int o = __p.__offset(52); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
public float? MaybeF32 { get { int o = __p.__offset(54); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
public float DefaultF32 { get { int o = __p.__offset(56); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)42.0f; } }
public double JustF64 { get { int o = __p.__offset(58); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
public double? MaybeF64 { get { int o = __p.__offset(60); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double?)null; } }
public double DefaultF64 { get { int o = __p.__offset(62); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)42.0; } }
public bool JustBool { get { int o = __p.__offset(64); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
public bool? MaybeBool { get { int o = __p.__offset(66); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
public bool DefaultBool { get { int o = __p.__offset(68); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)true; } }
public optional_scalars.OptionalByte JustEnum { get { int o = __p.__offset(70); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : optional_scalars.OptionalByte.None; } }
public optional_scalars.OptionalByte? MaybeEnum { get { int o = __p.__offset(72); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : (optional_scalars.OptionalByte?)null; } }
public optional_scalars.OptionalByte DefaultEnum { get { int o = __p.__offset(74); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : optional_scalars.OptionalByte.One; } }
public static Offset<optional_scalars.ScalarStuff> CreateScalarStuff(FlatBufferBuilder builder,
sbyte just_i8 = 0,
sbyte? maybe_i8 = null,
sbyte default_i8 = 42,
byte just_u8 = 0,
byte? maybe_u8 = null,
byte default_u8 = 42,
short just_i16 = 0,
short? maybe_i16 = null,
short default_i16 = 42,
ushort just_u16 = 0,
ushort? maybe_u16 = null,
ushort default_u16 = 42,
int just_i32 = 0,
int? maybe_i32 = null,
int default_i32 = 42,
uint just_u32 = 0,
uint? maybe_u32 = null,
uint default_u32 = 42,
long just_i64 = 0,
long? maybe_i64 = null,
long default_i64 = 42,
ulong just_u64 = 0,
ulong? maybe_u64 = null,
ulong default_u64 = 42,
float just_f32 = 0.0f,
float? maybe_f32 = null,
float default_f32 = 42.0f,
double just_f64 = 0.0,
double? maybe_f64 = null,
double default_f64 = 42.0,
bool just_bool = false,
bool? maybe_bool = null,
bool default_bool = true,
optional_scalars.OptionalByte just_enum = optional_scalars.OptionalByte.None,
optional_scalars.OptionalByte? maybe_enum = null,
optional_scalars.OptionalByte default_enum = optional_scalars.OptionalByte.One) {
builder.StartTable(36);
ScalarStuff.AddDefaultF64(builder, default_f64);
ScalarStuff.AddMaybeF64(builder, maybe_f64);
ScalarStuff.AddJustF64(builder, just_f64);
ScalarStuff.AddDefaultU64(builder, default_u64);
ScalarStuff.AddMaybeU64(builder, maybe_u64);
ScalarStuff.AddJustU64(builder, just_u64);
ScalarStuff.AddDefaultI64(builder, default_i64);
ScalarStuff.AddMaybeI64(builder, maybe_i64);
ScalarStuff.AddJustI64(builder, just_i64);
ScalarStuff.AddDefaultF32(builder, default_f32);
ScalarStuff.AddMaybeF32(builder, maybe_f32);
ScalarStuff.AddJustF32(builder, just_f32);
ScalarStuff.AddDefaultU32(builder, default_u32);
ScalarStuff.AddMaybeU32(builder, maybe_u32);
ScalarStuff.AddJustU32(builder, just_u32);
ScalarStuff.AddDefaultI32(builder, default_i32);
ScalarStuff.AddMaybeI32(builder, maybe_i32);
ScalarStuff.AddJustI32(builder, just_i32);
ScalarStuff.AddDefaultU16(builder, default_u16);
ScalarStuff.AddMaybeU16(builder, maybe_u16);
ScalarStuff.AddJustU16(builder, just_u16);
ScalarStuff.AddDefaultI16(builder, default_i16);
ScalarStuff.AddMaybeI16(builder, maybe_i16);
ScalarStuff.AddJustI16(builder, just_i16);
ScalarStuff.AddDefaultEnum(builder, default_enum);
ScalarStuff.AddMaybeEnum(builder, maybe_enum);
ScalarStuff.AddJustEnum(builder, just_enum);
ScalarStuff.AddDefaultBool(builder, default_bool);
ScalarStuff.AddMaybeBool(builder, maybe_bool);
ScalarStuff.AddJustBool(builder, just_bool);
ScalarStuff.AddDefaultU8(builder, default_u8);
ScalarStuff.AddMaybeU8(builder, maybe_u8);
ScalarStuff.AddJustU8(builder, just_u8);
ScalarStuff.AddDefaultI8(builder, default_i8);
ScalarStuff.AddMaybeI8(builder, maybe_i8);
ScalarStuff.AddJustI8(builder, just_i8);
return ScalarStuff.EndScalarStuff(builder);
}
public static void StartScalarStuff(FlatBufferBuilder builder) { builder.StartTable(36); }
public static void AddJustI8(FlatBufferBuilder builder, sbyte justI8) { builder.AddSbyte(0, justI8, 0); }
public static void AddMaybeI8(FlatBufferBuilder builder, sbyte? maybeI8) { builder.AddSbyte(1, maybeI8); }
public static void AddDefaultI8(FlatBufferBuilder builder, sbyte defaultI8) { builder.AddSbyte(2, defaultI8, 42); }
public static void AddJustU8(FlatBufferBuilder builder, byte justU8) { builder.AddByte(3, justU8, 0); }
public static void AddMaybeU8(FlatBufferBuilder builder, byte? maybeU8) { builder.AddByte(4, maybeU8); }
public static void AddDefaultU8(FlatBufferBuilder builder, byte defaultU8) { builder.AddByte(5, defaultU8, 42); }
public static void AddJustI16(FlatBufferBuilder builder, short justI16) { builder.AddShort(6, justI16, 0); }
public static void AddMaybeI16(FlatBufferBuilder builder, short? maybeI16) { builder.AddShort(7, maybeI16); }
public static void AddDefaultI16(FlatBufferBuilder builder, short defaultI16) { builder.AddShort(8, defaultI16, 42); }
public static void AddJustU16(FlatBufferBuilder builder, ushort justU16) { builder.AddUshort(9, justU16, 0); }
public static void AddMaybeU16(FlatBufferBuilder builder, ushort? maybeU16) { builder.AddUshort(10, maybeU16); }
public static void AddDefaultU16(FlatBufferBuilder builder, ushort defaultU16) { builder.AddUshort(11, defaultU16, 42); }
public static void AddJustI32(FlatBufferBuilder builder, int justI32) { builder.AddInt(12, justI32, 0); }
public static void AddMaybeI32(FlatBufferBuilder builder, int? maybeI32) { builder.AddInt(13, maybeI32); }
public static void AddDefaultI32(FlatBufferBuilder builder, int defaultI32) { builder.AddInt(14, defaultI32, 42); }
public static void AddJustU32(FlatBufferBuilder builder, uint justU32) { builder.AddUint(15, justU32, 0); }
public static void AddMaybeU32(FlatBufferBuilder builder, uint? maybeU32) { builder.AddUint(16, maybeU32); }
public static void AddDefaultU32(FlatBufferBuilder builder, uint defaultU32) { builder.AddUint(17, defaultU32, 42); }
public static void AddJustI64(FlatBufferBuilder builder, long justI64) { builder.AddLong(18, justI64, 0); }
public static void AddMaybeI64(FlatBufferBuilder builder, long? maybeI64) { builder.AddLong(19, maybeI64); }
public static void AddDefaultI64(FlatBufferBuilder builder, long defaultI64) { builder.AddLong(20, defaultI64, 42); }
public static void AddJustU64(FlatBufferBuilder builder, ulong justU64) { builder.AddUlong(21, justU64, 0); }
public static void AddMaybeU64(FlatBufferBuilder builder, ulong? maybeU64) { builder.AddUlong(22, maybeU64); }
public static void AddDefaultU64(FlatBufferBuilder builder, ulong defaultU64) { builder.AddUlong(23, defaultU64, 42); }
public static void AddJustF32(FlatBufferBuilder builder, float justF32) { builder.AddFloat(24, justF32, 0.0f); }
public static void AddMaybeF32(FlatBufferBuilder builder, float? maybeF32) { builder.AddFloat(25, maybeF32); }
public static void AddDefaultF32(FlatBufferBuilder builder, float defaultF32) { builder.AddFloat(26, defaultF32, 42.0f); }
public static void AddJustF64(FlatBufferBuilder builder, double justF64) { builder.AddDouble(27, justF64, 0.0); }
public static void AddMaybeF64(FlatBufferBuilder builder, double? maybeF64) { builder.AddDouble(28, maybeF64); }
public static void AddDefaultF64(FlatBufferBuilder builder, double defaultF64) { builder.AddDouble(29, defaultF64, 42.0); }
public static void AddJustBool(FlatBufferBuilder builder, bool justBool) { builder.AddBool(30, justBool, false); }
public static void AddMaybeBool(FlatBufferBuilder builder, bool? maybeBool) { builder.AddBool(31, maybeBool); }
public static void AddDefaultBool(FlatBufferBuilder builder, bool defaultBool) { builder.AddBool(32, defaultBool, true); }
public static void AddJustEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte justEnum) { builder.AddSbyte(33, (sbyte)justEnum, 0); }
public static void AddMaybeEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte? maybeEnum) { builder.AddSbyte(34, (sbyte)maybeEnum); }
public static void AddDefaultEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte defaultEnum) { builder.AddSbyte(35, (sbyte)defaultEnum, 1); }
public static Offset<optional_scalars.ScalarStuff> EndScalarStuff(FlatBufferBuilder builder) {
int o = builder.EndTable();
return new Offset<optional_scalars.ScalarStuff>(o);
}
public static void FinishScalarStuffBuffer(FlatBufferBuilder builder, Offset<optional_scalars.ScalarStuff> offset) { builder.Finish(offset.Value, "NULL"); }
public static void FinishSizePrefixedScalarStuffBuffer(FlatBufferBuilder builder, Offset<optional_scalars.ScalarStuff> offset) { builder.FinishSizePrefixed(offset.Value, "NULL"); }
};
}