diff --git a/net/FlatBuffers/FlatBufferBuilder.cs b/net/FlatBuffers/FlatBufferBuilder.cs index ba3839488..c72b6248a 100644 --- a/net/FlatBuffers/FlatBufferBuilder.cs +++ b/net/FlatBuffers/FlatBufferBuilder.cs @@ -449,6 +449,15 @@ namespace FlatBuffers /// The default value to compare the value against public void AddBool(int o, bool x, bool d) { if (ForceDefaults || x != d) { AddBool(x); Slot(o); } } + /// + /// Adds a Boolean to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable boolean value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddBool(int o, bool? x) { if (x.HasValue) { AddBool(x.Value); Slot(o); } } + + /// /// Adds a SByte to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -458,6 +467,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddSbyte(int o, sbyte x, sbyte d) { if (ForceDefaults || x != d) { AddSbyte(x); Slot(o); } } + /// + /// Adds a SByte to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable sbyte value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddSbyte(int o, sbyte? x) { if (x.HasValue) { AddSbyte(x.Value); Slot(o); } } + /// /// Adds a Byte to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -467,6 +484,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddByte(int o, byte x, byte d) { if (ForceDefaults || x != d) { AddByte(x); Slot(o); } } + /// + /// Adds a Byte to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable byte value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddByte(int o, byte? x) { if (x.HasValue) { AddByte(x.Value); Slot(o); } } + /// /// Adds a Int16 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -476,6 +501,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddShort(int o, short x, int d) { if (ForceDefaults || x != d) { AddShort(x); Slot(o); } } + /// + /// Adds a Int16 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable int16 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddShort(int o, short? x) { if (x.HasValue) { AddShort(x.Value); Slot(o); } } + /// /// Adds a UInt16 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -485,6 +518,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddUshort(int o, ushort x, ushort d) { if (ForceDefaults || x != d) { AddUshort(x); Slot(o); } } + /// + /// Adds a Uint16 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable uint16 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddUshort(int o, ushort? x) { if (x.HasValue) { AddUshort(x.Value); Slot(o); } } + /// /// Adds an Int32 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -494,6 +535,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddInt(int o, int x, int d) { if (ForceDefaults || x != d) { AddInt(x); Slot(o); } } + /// + /// Adds a Int32 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable int32 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddInt(int o, int? x) { if (x.HasValue) { AddInt(x.Value); Slot(o); } } + /// /// Adds a UInt32 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -503,6 +552,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddUint(int o, uint x, uint d) { if (ForceDefaults || x != d) { AddUint(x); Slot(o); } } + /// + /// Adds a UInt32 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable uint32 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddUint(int o, uint? x) { if (x.HasValue) { AddUint(x.Value); Slot(o); } } + /// /// Adds an Int64 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -512,6 +569,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddLong(int o, long x, long d) { if (ForceDefaults || x != d) { AddLong(x); Slot(o); } } + /// + /// Adds a Int64 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable int64 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddLong(int o, long? x) { if (x.HasValue) { AddLong(x.Value); Slot(o); } } + /// /// Adds a UInt64 to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -521,6 +586,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddUlong(int o, ulong x, ulong d) { if (ForceDefaults || x != d) { AddUlong(x); Slot(o); } } + /// + /// Adds a UInt64 to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable int64 value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddUlong(int o, ulong? x) { if (x.HasValue) { AddUlong(x.Value); Slot(o); } } + /// /// Adds a Single to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -530,6 +603,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddFloat(int o, float x, double d) { if (ForceDefaults || x != d) { AddFloat(x); Slot(o); } } + /// + /// Adds a Single to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable single value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddFloat(int o, float? x) { if (x.HasValue) { AddFloat(x.Value); Slot(o); } } + /// /// Adds a Double to the Table at index `o` in its vtable using the value `x` and default `d` /// @@ -539,6 +620,14 @@ namespace FlatBuffers /// The default value to compare the value against public void AddDouble(int o, double x, double d) { if (ForceDefaults || x != d) { AddDouble(x); Slot(o); } } + /// + /// Adds a Double to the Table at index `o` in its vtable using the nullable value `x` + /// + /// The index into the vtable + /// The nullable double value to put into the buffer. If it doesn't have a value + /// it will skip writing to the buffer. + public void AddDouble(int o, double? x) { if (x.HasValue) { AddDouble(x.Value); Slot(o); } } + /// /// Adds a buffer offset to the Table at index `o` in its vtable using the value `x` and default `d` /// diff --git a/src/idl_gen_csharp.cpp b/src/idl_gen_csharp.cpp index 3c1331e32..f98df4cc7 100644 --- a/src/idl_gen_csharp.cpp +++ b/src/idl_gen_csharp.cpp @@ -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." + diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index 9eebac9d6..ca4500f9e 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -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); } diff --git a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs index 06bca0f39..e2b72c7ee 100644 --- a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs +++ b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs @@ -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() { diff --git a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj index 93b9f0729..bbbd7d812 100644 --- a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj +++ b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj @@ -128,6 +128,12 @@ union_vector\Rapunzel.cs + + optional_scalars\OptionalByte.cs + + + optional_scalars\ScalarStuff.cs + diff --git a/tests/FlatBuffers.Test/FlatBuffers.Test.csproj b/tests/FlatBuffers.Test/FlatBuffers.Test.csproj index e26f918eb..616ab1963 100644 --- a/tests/FlatBuffers.Test/FlatBuffers.Test.csproj +++ b/tests/FlatBuffers.Test/FlatBuffers.Test.csproj @@ -159,6 +159,12 @@ union_vector\Rapunzel.cs + + optional_scalars\OptionalByte.cs + + + optional_scalars\ScalarStuff.cs + diff --git a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs index 1324c8cb8..b4093d4db 100644 --- a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs +++ b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs @@ -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); + } } } diff --git a/tests/generate_code.bat b/tests/generate_code.bat index 025f8b041..1fc96a206 100644 --- a/tests/generate_code.bat +++ b/tests/generate_code.bat @@ -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 diff --git a/tests/generate_code.sh b/tests/generate_code.sh index bbba2a5fb..89d94297c 100755 --- a/tests/generate_code.sh +++ b/tests/generate_code.sh @@ -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 diff --git a/tests/optional_scalars/OptionalByte.cs b/tests/optional_scalars/OptionalByte.cs new file mode 100644 index 000000000..79a20045b --- /dev/null +++ b/tests/optional_scalars/OptionalByte.cs @@ -0,0 +1,16 @@ +// +// automatically generated by the FlatBuffers compiler, do not modify +// + +namespace optional_scalars +{ + +public enum OptionalByte : sbyte +{ + None = 0, + One = 1, + Two = 2, +}; + + +} diff --git a/tests/optional_scalars/ScalarStuff.cs b/tests/optional_scalars/ScalarStuff.cs new file mode 100644 index 000000000..a5c9ffb5e --- /dev/null +++ b/tests/optional_scalars/ScalarStuff.cs @@ -0,0 +1,183 @@ +// +// automatically generated by the FlatBuffers compiler, do not modify +// + +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 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 EndScalarStuff(FlatBufferBuilder builder) { + int o = builder.EndTable(); + return new Offset(o); + } + public static void FinishScalarStuffBuffer(FlatBufferBuilder builder, Offset offset) { builder.Finish(offset.Value, "NULL"); } + public static void FinishSizePrefixedScalarStuffBuffer(FlatBufferBuilder builder, Offset offset) { builder.FinishSizePrefixed(offset.Value, "NULL"); } +}; + + +}