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

Fix handling of +/-inf defaults in TS/rust/go/dart codegen (#7588)

Browse Source 
+/-inf were not being handled, and so invalid typescript was being
generated when a float/double had an infinite default value. NaN was
being handled correctly.

Co-authored-by: Derek Bailey <derekbailey@google.com>
Co-authored-by: Casper <casperneo@uchicago.edu>
This commit is contained in:
James Kuszmaul
2022-11-08 10:59:46 -08:00
committed by GitHub
parent 001adf782d
commit 8aa8b9139e
41 changed files with 8217 additions and 4647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
dart/test/flat_buffers_test.dart
View File

@@ -87,7 +87,10 @@ class CheckOtherLangaugesData {
'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
'nativeInline: null, '
'longEnumNonEnumDefault: LongEnum{value: 0}, '
'longEnumNormalDefault: LongEnum{value: 2}}, '
'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
'-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
'testarrayofstring: [test1, test2], testarrayoftables: null, '
'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
@@ -110,7 +113,10 @@ class CheckOtherLangaugesData {
'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
'nativeInline: null, '
'longEnumNonEnumDefault: LongEnum{value: 0}, '
'longEnumNormalDefault: LongEnum{value: 2}}, '
'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
'-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
'testnestedflatbuffer: null, testempty: null, testbool: true, '
'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
'testhashs64Fnv1: 7930699090847568257, '
@@ -137,7 +143,10 @@ class CheckOtherLangaugesData {
'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '
'nativeInline: Test{a: 1, b: 2}, '
'longEnumNonEnumDefault: LongEnum{value: 0}, '
'longEnumNormalDefault: LongEnum{value: 2}}',
'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
'-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}'
);
}
}

12
include/flatbuffers/util.h
View File

@@ -393,6 +393,18 @@ inline uint64_t StringToUInt(const char *s, int base = 10) {
return StringToIntegerImpl(&val, s, base) ? val : 0;
}
inline bool StringIsFlatbufferNan(const std::string &s) {
return s == "nan" || s == "+nan" || s == "-nan";
}
inline bool StringIsFlatbufferPositiveInfinity(const std::string &s) {
return s == "inf" || s == "+inf" || s == "infinity" || s == "+infinity";
}
inline bool StringIsFlatbufferNegativeInfinity(const std::string &s) {
return s == "-inf" || s == "-infinity";
}
typedef bool (*LoadFileFunction)(const char *filename, bool binary,
std::string *dest);
typedef bool (*FileExistsFunction)(const char *filename);

7
src/bfbs_gen_nim.cpp
View File

@@ -470,6 +470,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator {
std::string DefaultValue(const r::Field *field) const {
const r::BaseType base_type = field->type()->base_type();
if (IsFloatingPoint(base_type)) {
if (field->default_real() != field->default_real()) {
return "NaN";
} else if (field->default_real() == std::numeric_limits<double>::infinity()) {
return "Inf";
} else if (field->default_real() == -std::numeric_limits<double>::infinity()) {
return "-Inf";
}
return NumToString(field->default_real());
}
if (IsBool(base_type)) {

20
src/idl_gen_dart.cpp
View File

@@ -16,6 +16,7 @@
// independent from idl_parser, since this code is not needed for most clients
#include <cassert>
#include <cmath>
#include "flatbuffers/code_generators.h"
#include "flatbuffers/flatbuffers.h"
@@ -721,16 +722,17 @@ class DartGenerator : public BaseGenerator {
if (!value.constant.empty() && value.constant != "0") {
if (IsBool(value.type.base_type)) {
return "true";
} else if (value.constant == "nan" || value.constant == "+nan" ||
value.constant == "-nan") {
return "double.nan";
} else if (value.constant == "inf" || value.constant == "+inf") {
return "double.infinity";
} else if (value.constant == "-inf") {
return "double.negativeInfinity";
} else {
return value.constant;
}
if (IsScalar(value.type.base_type)) {
if (StringIsFlatbufferNan(value.constant)) {
return "double.nan";
} else if (StringIsFlatbufferPositiveInfinity(value.constant)) {
return "double.infinity";
} else if (StringIsFlatbufferNegativeInfinity(value.constant)) {
return "double.negativeInfinity";
}
}
return value.constant;
} else if (IsBool(value.type.base_type)) {
return "false";
} else if (IsScalar(value.type.base_type) && !IsUnion(value.type)) {

27
src/idl_gen_go.cpp
View File

@@ -17,6 +17,7 @@
// independent from idl_parser, since this code is not needed for most clients
#include <algorithm>
#include <cmath>
#include <sstream>
#include <string>
@@ -102,6 +103,7 @@ class GoGenerator : public BaseGenerator {
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
tracked_imported_namespaces_.clear();
needs_math_import_ = false;
needs_imports = false;
std::string enumcode;
GenEnum(**it, &enumcode);
@@ -121,6 +123,7 @@ class GoGenerator : public BaseGenerator {
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
tracked_imported_namespaces_.clear();
needs_math_import_ = false;
std::string declcode;
GenStruct(**it, &declcode);
if (parser_.opts.one_file) {
@@ -154,6 +157,7 @@ class GoGenerator : public BaseGenerator {
}
};
std::set<const Namespace *, NamespacePtrLess> tracked_imported_namespaces_;
bool needs_math_import_ = false;
// Most field accessors need to retrieve and test the field offset first,
// this is the prefix code for that.
@@ -1277,6 +1281,23 @@ class GoGenerator : public BaseGenerator {
switch (field.value.type.base_type) {
case BASE_TYPE_BOOL:
return field.value.constant == "0" ? "false" : "true";
case BASE_TYPE_FLOAT:
case BASE_TYPE_DOUBLE: {
const std::string float_type =
field.value.type.base_type == BASE_TYPE_FLOAT ? "float32"
: "float64";
if (StringIsFlatbufferNan(field.value.constant)) {
needs_math_import_ = true;
return float_type + "(math.NaN())";
} else if (StringIsFlatbufferPositiveInfinity(field.value.constant)) {
needs_math_import_ = true;
return float_type + "(math.Inf(1))";
} else if (StringIsFlatbufferNegativeInfinity(field.value.constant)) {
needs_math_import_ = true;
return float_type + "(math.Inf(-1))";
}
return field.value.constant;
}
default: return field.value.constant;
}
}
@@ -1330,6 +1351,8 @@ class GoGenerator : public BaseGenerator {
if (needs_imports) {
code += "import (\n";
if (is_enum) { code += "\t\"strconv\"\n\n"; }
// math is needed to support non-finite scalar default values.
if (needs_math_import_) { code += "\t\"math\"\n\n"; }
if (!parser_.opts.go_import.empty()) {
code += "\tflatbuffers \"" + parser_.opts.go_import + "\"\n";
} else {
@@ -1346,6 +1369,10 @@ class GoGenerator : public BaseGenerator {
code += ")\n\n";
} else {
if (is_enum) { code += "import \"strconv\"\n\n"; }
if (needs_math_import_) {
// math is needed to support non-finite scalar default values.
code += "import \"math\"\n\n";
}
}
}

15
src/idl_gen_rust.cpp
View File

@@ -16,6 +16,8 @@
// independent from idl_parser, since this code is not needed for most clients
#include <cmath>
#include "flatbuffers/code_generators.h"
#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/idl.h"
@@ -1046,8 +1048,19 @@ class RustGenerator : public BaseGenerator {
if (field.IsOptional() && !IsUnion(field.value.type)) { return "None"; }
}
switch (GetFullType(field.value.type)) {
case ftInteger:
case ftInteger: {
return field.value.constant;
}
case ftFloat: {
const std::string float_prefix =
(field.value.type.base_type == BASE_TYPE_FLOAT) ? "f32::" : "f64::";
if (StringIsFlatbufferNan(field.value.constant)) {
return float_prefix + "NAN";
} else if (StringIsFlatbufferPositiveInfinity(field.value.constant)) {
return float_prefix + "INFINITY";
} else if (StringIsFlatbufferNegativeInfinity(field.value.constant)) {
return float_prefix + "NEG_INFINITY";
}
return field.value.constant;
}
case ftBool: {

12
src/idl_gen_ts.cpp
View File

@@ -16,6 +16,7 @@
#include <algorithm>
#include <cassert>
#include <cmath>
#include <unordered_map>
#include <unordered_set>
@@ -454,9 +455,16 @@ class TsGenerator : public BaseGenerator {
return "BigInt('" + value.constant + "')";
}
default:
if (value.constant == "nan") { return "NaN"; }
default: {
if (StringIsFlatbufferNan(value.constant)) {
return "NaN";
} else if (StringIsFlatbufferPositiveInfinity(value.constant)) {
return "Infinity";
} else if (StringIsFlatbufferNegativeInfinity(value.constant)) {
return "-Infinity";
}
return value.constant;
}
}
}

88
tests/MyGame/Example/Monster.cs
View File

@@ -215,6 +215,22 @@ public struct Monster : IFlatbufferObject
public bool MutateLongEnumNonEnumDefault(MyGame.Example.LongEnum long_enum_non_enum_default) { int o = __p.__offset(108); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_non_enum_default); return true; } else { return false; } }
public MyGame.Example.LongEnum LongEnumNormalDefault { get { int o = __p.__offset(110); return o != 0 ? (MyGame.Example.LongEnum)__p.bb.GetUlong(o + __p.bb_pos) : MyGame.Example.LongEnum.LongOne; } }
public bool MutateLongEnumNormalDefault(MyGame.Example.LongEnum long_enum_normal_default) { int o = __p.__offset(110); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_normal_default); return true; } else { return false; } }
public float NanDefault { get { int o = __p.__offset(112); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NaN; } }
public bool MutateNanDefault(float nan_default) { int o = __p.__offset(112); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, nan_default); return true; } else { return false; } }
public float InfDefault { get { int o = __p.__offset(114); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
public bool MutateInfDefault(float inf_default) { int o = __p.__offset(114); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, inf_default); return true; } else { return false; } }
public float PositiveInfDefault { get { int o = __p.__offset(116); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
public bool MutatePositiveInfDefault(float positive_inf_default) { int o = __p.__offset(116); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_inf_default); return true; } else { return false; } }
public float InfinityDefault { get { int o = __p.__offset(118); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
public bool MutateInfinityDefault(float infinity_default) { int o = __p.__offset(118); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, infinity_default); return true; } else { return false; } }
public float PositiveInfinityDefault { get { int o = __p.__offset(120); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
public bool MutatePositiveInfinityDefault(float positive_infinity_default) { int o = __p.__offset(120); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_infinity_default); return true; } else { return false; } }
public float NegativeInfDefault { get { int o = __p.__offset(122); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
public bool MutateNegativeInfDefault(float negative_inf_default) { int o = __p.__offset(122); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_inf_default); return true; } else { return false; } }
public float NegativeInfinityDefault { get { int o = __p.__offset(124); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
public bool MutateNegativeInfinityDefault(float negative_infinity_default) { int o = __p.__offset(124); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_infinity_default); return true; } else { return false; } }
public double DoubleInfDefault { get { int o = __p.__offset(126); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)Double.PositiveInfinity; } }
public bool MutateDoubleInfDefault(double double_inf_default) { int o = __p.__offset(126); if (o != 0) { __p.bb.PutDouble(o + __p.bb_pos, double_inf_default); return true; } else { return false; } }
public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
MyGame.Example.Vec3T pos = null,
@@ -269,8 +285,17 @@ public struct Monster : IFlatbufferObject
VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset),
MyGame.Example.TestT native_inline = null,
MyGame.Example.LongEnum long_enum_non_enum_default = 0,
MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne) {
builder.StartTable(54);
MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne,
float nan_default = Single.NaN,
float inf_default = Single.PositiveInfinity,
float positive_inf_default = Single.PositiveInfinity,
float infinity_default = Single.PositiveInfinity,
float positive_infinity_default = Single.PositiveInfinity,
float negative_inf_default = Single.NegativeInfinity,
float negative_infinity_default = Single.NegativeInfinity,
double double_inf_default = Double.PositiveInfinity) {
builder.StartTable(62);
Monster.AddDoubleInfDefault(builder, double_inf_default);
Monster.AddLongEnumNormalDefault(builder, long_enum_normal_default);
Monster.AddLongEnumNonEnumDefault(builder, long_enum_non_enum_default);
Monster.AddNonOwningReference(builder, non_owning_reference);
@@ -280,6 +305,13 @@ public struct Monster : IFlatbufferObject
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
Monster.AddNegativeInfinityDefault(builder, negative_infinity_default);
Monster.AddNegativeInfDefault(builder, negative_inf_default);
Monster.AddPositiveInfinityDefault(builder, positive_infinity_default);
Monster.AddInfinityDefault(builder, infinity_default);
Monster.AddPositiveInfDefault(builder, positive_inf_default);
Monster.AddInfDefault(builder, inf_default);
Monster.AddNanDefault(builder, nan_default);
Monster.AddNativeInline(builder, MyGame.Example.Test.Pack(builder, native_inline));
Monster.AddScalarKeySortedTables(builder, scalar_key_sorted_tablesOffset);
Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
@@ -327,7 +359,7 @@ public struct Monster : IFlatbufferObject
return Monster.EndMonster(builder);
}
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(54); }
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(62); }
public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
@@ -469,6 +501,14 @@ public struct Monster : IFlatbufferObject
public static void AddNativeInline(FlatBufferBuilder builder, Offset<MyGame.Example.Test> nativeInlineOffset) { builder.AddStruct(51, nativeInlineOffset.Value, 0); }
public static void AddLongEnumNonEnumDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNonEnumDefault) { builder.AddUlong(52, (ulong)longEnumNonEnumDefault, 0); }
public static void AddLongEnumNormalDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNormalDefault) { builder.AddUlong(53, (ulong)longEnumNormalDefault, 2); }
public static void AddNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.AddFloat(54, nanDefault, Single.NaN); }
public static void AddInfDefault(FlatBufferBuilder builder, float infDefault) { builder.AddFloat(55, infDefault, Single.PositiveInfinity); }
public static void AddPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.AddFloat(56, positiveInfDefault, Single.PositiveInfinity); }
public static void AddInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.AddFloat(57, infinityDefault, Single.PositiveInfinity); }
public static void AddPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.AddFloat(58, positiveInfinityDefault, Single.PositiveInfinity); }
public static void AddNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.AddFloat(59, negativeInfDefault, Single.NegativeInfinity); }
public static void AddNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.AddFloat(60, negativeInfinityDefault, Single.NegativeInfinity); }
public static void AddDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.AddDouble(61, doubleInfDefault, Double.PositiveInfinity); }
public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
int o = builder.EndTable();
builder.Required(o, 10); // name
@@ -620,6 +660,14 @@ public struct Monster : IFlatbufferObject
_o.NativeInline = this.NativeInline.HasValue ? this.NativeInline.Value.UnPack() : null;
_o.LongEnumNonEnumDefault = this.LongEnumNonEnumDefault;
_o.LongEnumNormalDefault = this.LongEnumNormalDefault;
_o.NanDefault = this.NanDefault;
_o.InfDefault = this.InfDefault;
_o.PositiveInfDefault = this.PositiveInfDefault;
_o.InfinityDefault = this.InfinityDefault;
_o.PositiveInfinityDefault = this.PositiveInfinityDefault;
_o.NegativeInfDefault = this.NegativeInfDefault;
_o.NegativeInfinityDefault = this.NegativeInfinityDefault;
_o.DoubleInfDefault = this.DoubleInfDefault;
}
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -796,7 +844,15 @@ public struct Monster : IFlatbufferObject
_scalar_key_sorted_tables,
_o.NativeInline,
_o.LongEnumNonEnumDefault,
_o.LongEnumNormalDefault);
_o.LongEnumNormalDefault,
_o.NanDefault,
_o.InfDefault,
_o.PositiveInfDefault,
_o.InfinityDefault,
_o.PositiveInfinityDefault,
_o.NegativeInfDefault,
_o.NegativeInfinityDefault,
_o.DoubleInfDefault);
}
}
@@ -949,6 +1005,22 @@ public class MonsterT
public MyGame.Example.LongEnum LongEnumNonEnumDefault { get; set; }
[Newtonsoft.Json.JsonProperty("long_enum_normal_default")]
public MyGame.Example.LongEnum LongEnumNormalDefault { get; set; }
[Newtonsoft.Json.JsonProperty("nan_default")]
public float NanDefault { get; set; }
[Newtonsoft.Json.JsonProperty("inf_default")]
public float InfDefault { get; set; }
[Newtonsoft.Json.JsonProperty("positive_inf_default")]
public float PositiveInfDefault { get; set; }
[Newtonsoft.Json.JsonProperty("infinity_default")]
public float InfinityDefault { get; set; }
[Newtonsoft.Json.JsonProperty("positive_infinity_default")]
public float PositiveInfinityDefault { get; set; }
[Newtonsoft.Json.JsonProperty("negative_inf_default")]
public float NegativeInfDefault { get; set; }
[Newtonsoft.Json.JsonProperty("negative_infinity_default")]
public float NegativeInfinityDefault { get; set; }
[Newtonsoft.Json.JsonProperty("double_inf_default")]
public double DoubleInfDefault { get; set; }
public MonsterT() {
this.Pos = new MyGame.Example.Vec3T();
@@ -1001,6 +1073,14 @@ public class MonsterT
this.NativeInline = new MyGame.Example.TestT();
this.LongEnumNonEnumDefault = 0;
this.LongEnumNormalDefault = MyGame.Example.LongEnum.LongOne;
this.NanDefault = Single.NaN;
this.InfDefault = Single.PositiveInfinity;
this.PositiveInfDefault = Single.PositiveInfinity;
this.InfinityDefault = Single.PositiveInfinity;
this.PositiveInfinityDefault = Single.PositiveInfinity;
this.NegativeInfDefault = Single.NegativeInfinity;
this.NegativeInfinityDefault = Single.NegativeInfinity;
this.DoubleInfDefault = Double.PositiveInfinity;
}
public static MonsterT DeserializeFromJson(string jsonText) {

148
tests/MyGame/Example/Monster.go
View File

@@ -3,6 +3,8 @@
package Example
import (
"math"
flatbuffers "github.com/google/flatbuffers/go"
MyGame "MyGame"
@@ -60,6 +62,14 @@ type MonsterT struct {
NativeInline *TestT `json:"native_inline"`
LongEnumNonEnumDefault LongEnum `json:"long_enum_non_enum_default"`
LongEnumNormalDefault LongEnum `json:"long_enum_normal_default"`
NanDefault float32 `json:"nan_default"`
InfDefault float32 `json:"inf_default"`
PositiveInfDefault float32 `json:"positive_inf_default"`
InfinityDefault float32 `json:"infinity_default"`
PositiveInfinityDefault float32 `json:"positive_infinity_default"`
NegativeInfDefault float32 `json:"negative_inf_default"`
NegativeInfinityDefault float32 `json:"negative_infinity_default"`
DoubleInfDefault float64 `json:"double_inf_default"`
}
func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -320,6 +330,14 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
MonsterAddNativeInline(builder, nativeInlineOffset)
MonsterAddLongEnumNonEnumDefault(builder, t.LongEnumNonEnumDefault)
MonsterAddLongEnumNormalDefault(builder, t.LongEnumNormalDefault)
MonsterAddNanDefault(builder, t.NanDefault)
MonsterAddInfDefault(builder, t.InfDefault)
MonsterAddPositiveInfDefault(builder, t.PositiveInfDefault)
MonsterAddInfinityDefault(builder, t.InfinityDefault)
MonsterAddPositiveInfinityDefault(builder, t.PositiveInfinityDefault)
MonsterAddNegativeInfDefault(builder, t.NegativeInfDefault)
MonsterAddNegativeInfinityDefault(builder, t.NegativeInfinityDefault)
MonsterAddDoubleInfDefault(builder, t.DoubleInfDefault)
return MonsterEnd(builder)
}
@@ -461,6 +479,14 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
t.NativeInline = rcv.NativeInline(nil).UnPack()
t.LongEnumNonEnumDefault = rcv.LongEnumNonEnumDefault()
t.LongEnumNormalDefault = rcv.LongEnumNormalDefault()
t.NanDefault = rcv.NanDefault()
t.InfDefault = rcv.InfDefault()
t.PositiveInfDefault = rcv.PositiveInfDefault()
t.InfinityDefault = rcv.InfinityDefault()
t.PositiveInfinityDefault = rcv.PositiveInfinityDefault()
t.NegativeInfDefault = rcv.NegativeInfDefault()
t.NegativeInfinityDefault = rcv.NegativeInfinityDefault()
t.DoubleInfDefault = rcv.DoubleInfDefault()
}
func (rcv *Monster) UnPack() *MonsterT {
@@ -1386,8 +1412,104 @@ func (rcv *Monster) MutateLongEnumNormalDefault(n LongEnum) bool {
return rcv._tab.MutateUint64Slot(110, uint64(n))
}
func (rcv *Monster) NanDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(112))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.NaN())
}
func (rcv *Monster) MutateNanDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(112, n)
}
func (rcv *Monster) InfDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(114))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(1))
}
func (rcv *Monster) MutateInfDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(114, n)
}
func (rcv *Monster) PositiveInfDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(116))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(1))
}
func (rcv *Monster) MutatePositiveInfDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(116, n)
}
func (rcv *Monster) InfinityDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(118))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(1))
}
func (rcv *Monster) MutateInfinityDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(118, n)
}
func (rcv *Monster) PositiveInfinityDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(120))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(1))
}
func (rcv *Monster) MutatePositiveInfinityDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(120, n)
}
func (rcv *Monster) NegativeInfDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(122))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(-1))
}
func (rcv *Monster) MutateNegativeInfDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(122, n)
}
func (rcv *Monster) NegativeInfinityDefault() float32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(124))
if o != 0 {
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
}
return float32(math.Inf(-1))
}
func (rcv *Monster) MutateNegativeInfinityDefault(n float32) bool {
return rcv._tab.MutateFloat32Slot(124, n)
}
func (rcv *Monster) DoubleInfDefault() float64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(126))
if o != 0 {
return rcv._tab.GetFloat64(o + rcv._tab.Pos)
}
return float64(math.Inf(1))
}
func (rcv *Monster) MutateDoubleInfDefault(n float64) bool {
return rcv._tab.MutateFloat64Slot(126, n)
}
func MonsterStart(builder *flatbuffers.Builder) {
builder.StartObject(54)
builder.StartObject(62)
}
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1608,6 +1730,30 @@ func MonsterAddLongEnumNonEnumDefault(builder *flatbuffers.Builder, longEnumNonE
func MonsterAddLongEnumNormalDefault(builder *flatbuffers.Builder, longEnumNormalDefault LongEnum) {
builder.PrependUint64Slot(53, uint64(longEnumNormalDefault), 2)
}
func MonsterAddNanDefault(builder *flatbuffers.Builder, nanDefault float32) {
builder.PrependFloat32Slot(54, nanDefault, float32(math.NaN()))
}
func MonsterAddInfDefault(builder *flatbuffers.Builder, infDefault float32) {
builder.PrependFloat32Slot(55, infDefault, float32(math.Inf(1)))
}
func MonsterAddPositiveInfDefault(builder *flatbuffers.Builder, positiveInfDefault float32) {
builder.PrependFloat32Slot(56, positiveInfDefault, float32(math.Inf(1)))
}
func MonsterAddInfinityDefault(builder *flatbuffers.Builder, infinityDefault float32) {
builder.PrependFloat32Slot(57, infinityDefault, float32(math.Inf(1)))
}
func MonsterAddPositiveInfinityDefault(builder *flatbuffers.Builder, positiveInfinityDefault float32) {
builder.PrependFloat32Slot(58, positiveInfinityDefault, float32(math.Inf(1)))
}
func MonsterAddNegativeInfDefault(builder *flatbuffers.Builder, negativeInfDefault float32) {
builder.PrependFloat32Slot(59, negativeInfDefault, float32(math.Inf(-1)))
}
func MonsterAddNegativeInfinityDefault(builder *flatbuffers.Builder, negativeInfinityDefault float32) {
builder.PrependFloat32Slot(60, negativeInfinityDefault, float32(math.Inf(-1)))
}
func MonsterAddDoubleInfDefault(builder *flatbuffers.Builder, doubleInfDefault float64) {
builder.PrependFloat64Slot(61, doubleInfDefault, float64(math.Inf(1)))
}
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}

50
tests/MyGame/Example/Monster.java
View File

@@ -216,8 +216,24 @@ public final class Monster extends Table {
public boolean mutateLongEnumNonEnumDefault(long long_enum_non_enum_default) { int o = __offset(108); if (o != 0) { bb.putLong(o + bb_pos, long_enum_non_enum_default); return true; } else { return false; } }
public long longEnumNormalDefault() { int o = __offset(110); return o != 0 ? bb.getLong(o + bb_pos) : 2L; }
public boolean mutateLongEnumNormalDefault(long long_enum_normal_default) { int o = __offset(110); if (o != 0) { bb.putLong(o + bb_pos, long_enum_normal_default); return true; } else { return false; } }
public float nanDefault() { int o = __offset(112); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NaN; }
public boolean mutateNanDefault(float nan_default) { int o = __offset(112); if (o != 0) { bb.putFloat(o + bb_pos, nan_default); return true; } else { return false; } }
public float infDefault() { int o = __offset(114); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
public boolean mutateInfDefault(float inf_default) { int o = __offset(114); if (o != 0) { bb.putFloat(o + bb_pos, inf_default); return true; } else { return false; } }
public float positiveInfDefault() { int o = __offset(116); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
public boolean mutatePositiveInfDefault(float positive_inf_default) { int o = __offset(116); if (o != 0) { bb.putFloat(o + bb_pos, positive_inf_default); return true; } else { return false; } }
public float infinityDefault() { int o = __offset(118); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
public boolean mutateInfinityDefault(float infinity_default) { int o = __offset(118); if (o != 0) { bb.putFloat(o + bb_pos, infinity_default); return true; } else { return false; } }
public float positiveInfinityDefault() { int o = __offset(120); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
public boolean mutatePositiveInfinityDefault(float positive_infinity_default) { int o = __offset(120); if (o != 0) { bb.putFloat(o + bb_pos, positive_infinity_default); return true; } else { return false; } }
public float negativeInfDefault() { int o = __offset(122); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
public boolean mutateNegativeInfDefault(float negative_inf_default) { int o = __offset(122); if (o != 0) { bb.putFloat(o + bb_pos, negative_inf_default); return true; } else { return false; } }
public float negativeInfinityDefault() { int o = __offset(124); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
public boolean mutateNegativeInfinityDefault(float negative_infinity_default) { int o = __offset(124); if (o != 0) { bb.putFloat(o + bb_pos, negative_infinity_default); return true; } else { return false; } }
public double doubleInfDefault() { int o = __offset(126); return o != 0 ? bb.getDouble(o + bb_pos) : Double.POSITIVE_INFINITY; }
public boolean mutateDoubleInfDefault(double double_inf_default) { int o = __offset(126); if (o != 0) { bb.putDouble(o + bb_pos, double_inf_default); return true; } else { return false; } }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(54); }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(62); }
public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
@@ -313,6 +329,14 @@ public final class Monster extends Table {
public static void addNativeInline(FlatBufferBuilder builder, int nativeInlineOffset) { builder.addStruct(51, nativeInlineOffset, 0); }
public static void addLongEnumNonEnumDefault(FlatBufferBuilder builder, long longEnumNonEnumDefault) { builder.addLong(52, longEnumNonEnumDefault, 0L); }
public static void addLongEnumNormalDefault(FlatBufferBuilder builder, long longEnumNormalDefault) { builder.addLong(53, longEnumNormalDefault, 2L); }
public static void addNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.addFloat(54, nanDefault, Float.NaN); }
public static void addInfDefault(FlatBufferBuilder builder, float infDefault) { builder.addFloat(55, infDefault, Float.POSITIVE_INFINITY); }
public static void addPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.addFloat(56, positiveInfDefault, Float.POSITIVE_INFINITY); }
public static void addInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.addFloat(57, infinityDefault, Float.POSITIVE_INFINITY); }
public static void addPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.addFloat(58, positiveInfinityDefault, Float.POSITIVE_INFINITY); }
public static void addNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.addFloat(59, negativeInfDefault, Float.NEGATIVE_INFINITY); }
public static void addNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.addFloat(60, negativeInfinityDefault, Float.NEGATIVE_INFINITY); }
public static void addDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY); }
public static int endMonster(FlatBufferBuilder builder) {
int o = builder.endTable();
builder.required(o, 10); // name
@@ -533,6 +557,22 @@ public final class Monster extends Table {
_o.setLongEnumNonEnumDefault(_oLongEnumNonEnumDefault);
long _oLongEnumNormalDefault = longEnumNormalDefault();
_o.setLongEnumNormalDefault(_oLongEnumNormalDefault);
float _oNanDefault = nanDefault();
_o.setNanDefault(_oNanDefault);
float _oInfDefault = infDefault();
_o.setInfDefault(_oInfDefault);
float _oPositiveInfDefault = positiveInfDefault();
_o.setPositiveInfDefault(_oPositiveInfDefault);
float _oInfinityDefault = infinityDefault();
_o.setInfinityDefault(_oInfinityDefault);
float _oPositiveInfinityDefault = positiveInfinityDefault();
_o.setPositiveInfinityDefault(_oPositiveInfinityDefault);
float _oNegativeInfDefault = negativeInfDefault();
_o.setNegativeInfDefault(_oNegativeInfDefault);
float _oNegativeInfinityDefault = negativeInfinityDefault();
_o.setNegativeInfinityDefault(_oNegativeInfinityDefault);
double _oDoubleInfDefault = doubleInfDefault();
_o.setDoubleInfDefault(_oDoubleInfDefault);
}
public static int pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return 0;
@@ -725,6 +765,14 @@ public final class Monster extends Table {
addNativeInline(builder, MyGame.Example.Test.pack(builder, _o.getNativeInline()));
addLongEnumNonEnumDefault(builder, _o.getLongEnumNonEnumDefault());
addLongEnumNormalDefault(builder, _o.getLongEnumNormalDefault());
addNanDefault(builder, _o.getNanDefault());
addInfDefault(builder, _o.getInfDefault());
addPositiveInfDefault(builder, _o.getPositiveInfDefault());
addInfinityDefault(builder, _o.getInfinityDefault());
addPositiveInfinityDefault(builder, _o.getPositiveInfinityDefault());
addNegativeInfDefault(builder, _o.getNegativeInfDefault());
addNegativeInfinityDefault(builder, _o.getNegativeInfinityDefault());
addDoubleInfDefault(builder, _o.getDoubleInfDefault());
return endMonster(builder);
}
}

122
tests/MyGame/Example/Monster.kt
View File

@@ -870,6 +870,118 @@ class Monster : Table() {
false
}
}
val nanDefault : Float
get() {
val o = __offset(112)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NaN
}
fun mutateNanDefault(nanDefault: Float) : Boolean {
val o = __offset(112)
return if (o != 0) {
bb.putFloat(o + bb_pos, nanDefault)
true
} else {
false
}
}
val infDefault : Float
get() {
val o = __offset(114)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
}
fun mutateInfDefault(infDefault: Float) : Boolean {
val o = __offset(114)
return if (o != 0) {
bb.putFloat(o + bb_pos, infDefault)
true
} else {
false
}
}
val positiveInfDefault : Float
get() {
val o = __offset(116)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
}
fun mutatePositiveInfDefault(positiveInfDefault: Float) : Boolean {
val o = __offset(116)
return if (o != 0) {
bb.putFloat(o + bb_pos, positiveInfDefault)
true
} else {
false
}
}
val infinityDefault : Float
get() {
val o = __offset(118)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
}
fun mutateInfinityDefault(infinityDefault: Float) : Boolean {
val o = __offset(118)
return if (o != 0) {
bb.putFloat(o + bb_pos, infinityDefault)
true
} else {
false
}
}
val positiveInfinityDefault : Float
get() {
val o = __offset(120)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
}
fun mutatePositiveInfinityDefault(positiveInfinityDefault: Float) : Boolean {
val o = __offset(120)
return if (o != 0) {
bb.putFloat(o + bb_pos, positiveInfinityDefault)
true
} else {
false
}
}
val negativeInfDefault : Float
get() {
val o = __offset(122)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
}
fun mutateNegativeInfDefault(negativeInfDefault: Float) : Boolean {
val o = __offset(122)
return if (o != 0) {
bb.putFloat(o + bb_pos, negativeInfDefault)
true
} else {
false
}
}
val negativeInfinityDefault : Float
get() {
val o = __offset(124)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
}
fun mutateNegativeInfinityDefault(negativeInfinityDefault: Float) : Boolean {
val o = __offset(124)
return if (o != 0) {
bb.putFloat(o + bb_pos, negativeInfinityDefault)
true
} else {
false
}
}
val doubleInfDefault : Double
get() {
val o = __offset(126)
return if(o != 0) bb.getDouble(o + bb_pos) else Double.POSITIVE_INFINITY
}
fun mutateDoubleInfDefault(doubleInfDefault: Double) : Boolean {
val o = __offset(126)
return if (o != 0) {
bb.putDouble(o + bb_pos, doubleInfDefault)
true
} else {
false
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
@@ -881,7 +993,7 @@ class Monster : Table() {
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(54)
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(62)
fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
@@ -1077,6 +1189,14 @@ class Monster : Table() {
fun addNativeInline(builder: FlatBufferBuilder, nativeInline: Int) = builder.addStruct(51, nativeInline, 0)
fun addLongEnumNonEnumDefault(builder: FlatBufferBuilder, longEnumNonEnumDefault: ULong) = builder.addLong(52, longEnumNonEnumDefault.toLong(), 0)
fun addLongEnumNormalDefault(builder: FlatBufferBuilder, longEnumNormalDefault: ULong) = builder.addLong(53, longEnumNormalDefault.toLong(), 2)
fun addNanDefault(builder: FlatBufferBuilder, nanDefault: Float) = builder.addFloat(54, nanDefault, Double.NaN)
fun addInfDefault(builder: FlatBufferBuilder, infDefault: Float) = builder.addFloat(55, infDefault, Double.POSITIVE_INFINITY)
fun addPositiveInfDefault(builder: FlatBufferBuilder, positiveInfDefault: Float) = builder.addFloat(56, positiveInfDefault, Double.POSITIVE_INFINITY)
fun addInfinityDefault(builder: FlatBufferBuilder, infinityDefault: Float) = builder.addFloat(57, infinityDefault, Double.POSITIVE_INFINITY)
fun addPositiveInfinityDefault(builder: FlatBufferBuilder, positiveInfinityDefault: Float) = builder.addFloat(58, positiveInfinityDefault, Double.POSITIVE_INFINITY)
fun addNegativeInfDefault(builder: FlatBufferBuilder, negativeInfDefault: Float) = builder.addFloat(59, negativeInfDefault, Double.NEGATIVE_INFINITY)
fun addNegativeInfinityDefault(builder: FlatBufferBuilder, negativeInfinityDefault: Float) = builder.addFloat(60, negativeInfinityDefault, Double.NEGATIVE_INFINITY)
fun addDoubleInfDefault(builder: FlatBufferBuilder, doubleInfDefault: Double) = builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)

98
tests/MyGame/Example/Monster.lua
View File

@@ -703,8 +703,72 @@ function mt:LongEnumNormalDefault()
return 2
end
function mt:NanDefault()
local o = self.view:Offset(112)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return nan
end
function mt:InfDefault()
local o = self.view:Offset(114)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return inf
end
function mt:PositiveInfDefault()
local o = self.view:Offset(116)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return inf
end
function mt:InfinityDefault()
local o = self.view:Offset(118)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return inf
end
function mt:PositiveInfinityDefault()
local o = self.view:Offset(120)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return inf
end
function mt:NegativeInfDefault()
local o = self.view:Offset(122)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return -inf
end
function mt:NegativeInfinityDefault()
local o = self.view:Offset(124)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
end
return -inf
end
function mt:DoubleInfDefault()
local o = self.view:Offset(126)
if o ~= 0 then
return self.view:Get(flatbuffers.N.Float64, self.view.pos + o)
end
return inf
end
function Monster.Start(builder)
builder:StartObject(54)
builder:StartObject(62)
end
function Monster.AddPos(builder, pos)
@@ -999,6 +1063,38 @@ function Monster.AddLongEnumNormalDefault(builder, longEnumNormalDefault)
builder:PrependUint64Slot(53, longEnumNormalDefault, 2)
end
function Monster.AddNanDefault(builder, nanDefault)
builder:PrependFloat32Slot(54, nanDefault, nan)
end
function Monster.AddInfDefault(builder, infDefault)
builder:PrependFloat32Slot(55, infDefault, inf)
end
function Monster.AddPositiveInfDefault(builder, positiveInfDefault)
builder:PrependFloat32Slot(56, positiveInfDefault, inf)
end
function Monster.AddInfinityDefault(builder, infinityDefault)
builder:PrependFloat32Slot(57, infinityDefault, inf)
end
function Monster.AddPositiveInfinityDefault(builder, positiveInfinityDefault)
builder:PrependFloat32Slot(58, positiveInfinityDefault, inf)
end
function Monster.AddNegativeInfDefault(builder, negativeInfDefault)
builder:PrependFloat32Slot(59, negativeInfDefault, -inf)
end
function Monster.AddNegativeInfinityDefault(builder, negativeInfinityDefault)
builder:PrependFloat32Slot(60, negativeInfinityDefault, -inf)
end
function Monster.AddDoubleInfDefault(builder, doubleInfDefault)
builder:PrependFloat64Slot(61, doubleInfDefault, inf)
end
function Monster.End(builder)
return builder:EndObject()
end

74
tests/MyGame/Example/Monster.nim
View File

@@ -510,8 +510,64 @@ func longEnumNormalDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum =
return type(result)(2)
func `longEnumNormalDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool =
return self.tab.MutateSlot(110, n)
func nanDefault*(self: Monster): float32 =
let o = self.tab.Offset(112)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return NaN
func `nanDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(112, n)
func infDefault*(self: Monster): float32 =
let o = self.tab.Offset(114)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return Inf
func `infDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(114, n)
func positiveInfDefault*(self: Monster): float32 =
let o = self.tab.Offset(116)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return Inf
func `positiveInfDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(116, n)
func infinityDefault*(self: Monster): float32 =
let o = self.tab.Offset(118)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return Inf
func `infinityDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(118, n)
func positiveInfinityDefault*(self: Monster): float32 =
let o = self.tab.Offset(120)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return Inf
func `positiveInfinityDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(120, n)
func negativeInfDefault*(self: Monster): float32 =
let o = self.tab.Offset(122)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return -Inf
func `negativeInfDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(122, n)
func negativeInfinityDefault*(self: Monster): float32 =
let o = self.tab.Offset(124)
if o != 0:
return Get[float32](self.tab, self.tab.Pos + o)
return -Inf
func `negativeInfinityDefault=`*(self: var Monster, n: float32): bool =
return self.tab.MutateSlot(124, n)
func doubleInfDefault*(self: Monster): float64 =
let o = self.tab.Offset(126)
if o != 0:
return Get[float64](self.tab, self.tab.Pos + o)
return Inf
func `doubleInfDefault=`*(self: var Monster, n: float64): bool =
return self.tab.MutateSlot(126, n)
proc MonsterStart*(builder: var Builder) =
builder.StartObject(54)
builder.StartObject(62)
proc MonsterAddpos*(builder: var Builder, pos: uoffset) =
builder.PrependStructSlot(0, pos, default(uoffset))
proc MonsterAddmana*(builder: var Builder, mana: int16) =
@@ -658,5 +714,21 @@ proc MonsterAddlongEnumNonEnumDefault*(builder: var Builder, longEnumNonEnumDefa
builder.PrependSlot(52, longEnumNonEnumDefault, default(uint64))
proc MonsterAddlongEnumNormalDefault*(builder: var Builder, longEnumNormalDefault: uint64) =
builder.PrependSlot(53, longEnumNormalDefault, default(uint64))
proc MonsterAddnanDefault*(builder: var Builder, nanDefault: float32) =
builder.PrependSlot(54, nanDefault, default(float32))
proc MonsterAddinfDefault*(builder: var Builder, infDefault: float32) =
builder.PrependSlot(55, infDefault, default(float32))
proc MonsterAddpositiveInfDefault*(builder: var Builder, positiveInfDefault: float32) =
builder.PrependSlot(56, positiveInfDefault, default(float32))
proc MonsterAddinfinityDefault*(builder: var Builder, infinityDefault: float32) =
builder.PrependSlot(57, infinityDefault, default(float32))
proc MonsterAddpositiveInfinityDefault*(builder: var Builder, positiveInfinityDefault: float32) =
builder.PrependSlot(58, positiveInfinityDefault, default(float32))
proc MonsterAddnegativeInfDefault*(builder: var Builder, negativeInfDefault: float32) =
builder.PrependSlot(59, negativeInfDefault, default(float32))
proc MonsterAddnegativeInfinityDefault*(builder: var Builder, negativeInfinityDefault: float32) =
builder.PrependSlot(60, negativeInfinityDefault, default(float32))
proc MonsterAdddoubleInfDefault*(builder: var Builder, doubleInfDefault: float64) =
builder.PrependSlot(61, doubleInfDefault, default(float64))
proc MonsterEnd*(builder: var Builder): uoffset =
return builder.EndObject()

166
tests/MyGame/Example/Monster.php
View File

@@ -754,22 +754,94 @@ class Monster extends Table
return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : \MyGame\Example\LongEnum::LongOne;
}
/**
* @return float
*/
public function getNanDefault()
{
$o = $this->__offset(112);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : nan;
}
/**
* @return float
*/
public function getInfDefault()
{
$o = $this->__offset(114);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : inf;
}
/**
* @return float
*/
public function getPositiveInfDefault()
{
$o = $this->__offset(116);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +inf;
}
/**
* @return float
*/
public function getInfinityDefault()
{
$o = $this->__offset(118);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : infinity;
}
/**
* @return float
*/
public function getPositiveInfinityDefault()
{
$o = $this->__offset(120);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +infinity;
}
/**
* @return float
*/
public function getNegativeInfDefault()
{
$o = $this->__offset(122);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -inf;
}
/**
* @return float
*/
public function getNegativeInfinityDefault()
{
$o = $this->__offset(124);
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -infinity;
}
/**
* @return double
*/
public function getDoubleInfDefault()
{
$o = $this->__offset(126);
return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : inf;
}
/**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMonster(FlatBufferBuilder $builder)
{
$builder->StartObject(54);
$builder->StartObject(62);
}
/**
* @param FlatBufferBuilder $builder
* @return Monster
*/
public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default)
public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default, $nan_default, $inf_default, $positive_inf_default, $infinity_default, $positive_infinity_default, $negative_inf_default, $negative_infinity_default, $double_inf_default)
{
$builder->startObject(54);
$builder->startObject(62);
self::addPos($builder, $pos);
self::addMana($builder, $mana);
self::addHp($builder, $hp);
@@ -823,6 +895,14 @@ class Monster extends Table
self::addNativeInline($builder, $native_inline);
self::addLongEnumNonEnumDefault($builder, $long_enum_non_enum_default);
self::addLongEnumNormalDefault($builder, $long_enum_normal_default);
self::addNanDefault($builder, $nan_default);
self::addInfDefault($builder, $inf_default);
self::addPositiveInfDefault($builder, $positive_inf_default);
self::addInfinityDefault($builder, $infinity_default);
self::addPositiveInfinityDefault($builder, $positive_infinity_default);
self::addNegativeInfDefault($builder, $negative_inf_default);
self::addNegativeInfinityDefault($builder, $negative_infinity_default);
self::addDoubleInfDefault($builder, $double_inf_default);
$o = $builder->endObject();
$builder->required($o, 10); // name
return $o;
@@ -1823,6 +1903,86 @@ class Monster extends Table
$builder->addUlongX(53, $longEnumNormalDefault, 2);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addNanDefault(FlatBufferBuilder $builder, $nanDefault)
{
$builder->addFloatX(54, $nanDefault, nan);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addInfDefault(FlatBufferBuilder $builder, $infDefault)
{
$builder->addFloatX(55, $infDefault, inf);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addPositiveInfDefault(FlatBufferBuilder $builder, $positiveInfDefault)
{
$builder->addFloatX(56, $positiveInfDefault, +inf);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addInfinityDefault(FlatBufferBuilder $builder, $infinityDefault)
{
$builder->addFloatX(57, $infinityDefault, infinity);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addPositiveInfinityDefault(FlatBufferBuilder $builder, $positiveInfinityDefault)
{
$builder->addFloatX(58, $positiveInfinityDefault, +infinity);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addNegativeInfDefault(FlatBufferBuilder $builder, $negativeInfDefault)
{
$builder->addFloatX(59, $negativeInfDefault, -inf);
}
/**
* @param FlatBufferBuilder $builder
* @param float
* @return void
*/
public static function addNegativeInfinityDefault(FlatBufferBuilder $builder, $negativeInfinityDefault)
{
$builder->addFloatX(60, $negativeInfinityDefault, -infinity);
}
/**
* @param FlatBufferBuilder $builder
* @param double
* @return void
*/
public static function addDoubleInfDefault(FlatBufferBuilder $builder, $doubleInfDefault)
{
$builder->addDoubleX(61, $doubleInfDefault, inf);
}
/**
* @param FlatBufferBuilder $builder
* @return int table offset

106
tests/MyGame/Example/Monster.py
View File

@@ -816,7 +816,63 @@ class Monster(object):
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 2
def MonsterStart(builder): builder.StartObject(54)
# Monster
def NanDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('nan')
# Monster
def InfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def PositiveInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def InfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def PositiveInfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def NegativeInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('-inf')
# Monster
def NegativeInfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('-inf')
# Monster
def DoubleInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
return float('inf')
def MonsterStart(builder): builder.StartObject(62)
def Start(builder):
return MonsterStart(builder)
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
@@ -1052,6 +1108,30 @@ def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
def AddNanDefault(builder, nanDefault):
return MonsterAddNanDefault(builder, nanDefault)
def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
def AddInfDefault(builder, infDefault):
return MonsterAddInfDefault(builder, infDefault)
def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
def AddPositiveInfDefault(builder, positiveInfDefault):
return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
def AddInfinityDefault(builder, infinityDefault):
return MonsterAddInfinityDefault(builder, infinityDefault)
def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
def AddNegativeInfDefault(builder, negativeInfDefault):
return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
def AddDoubleInfDefault(builder, doubleInfDefault):
return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
def MonsterEnd(builder): return builder.EndObject()
def End(builder):
return MonsterEnd(builder)
@@ -1128,6 +1208,14 @@ class MonsterT(object):
self.nativeInline = None # type: Optional[MyGame.Example.Test.TestT]
self.longEnumNonEnumDefault = 0 # type: int
self.longEnumNormalDefault = 2 # type: int
self.nanDefault = float('nan') # type: float
self.infDefault = float('inf') # type: float
self.positiveInfDefault = float('inf') # type: float
self.infinityDefault = float('inf') # type: float
self.positiveInfinityDefault = float('inf') # type: float
self.negativeInfDefault = float('-inf') # type: float
self.negativeInfinityDefault = float('-inf') # type: float
self.doubleInfDefault = float('inf') # type: float
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1329,6 +1417,14 @@ class MonsterT(object):
self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
self.longEnumNormalDefault = monster.LongEnumNormalDefault()
self.nanDefault = monster.NanDefault()
self.infDefault = monster.InfDefault()
self.positiveInfDefault = monster.PositiveInfDefault()
self.infinityDefault = monster.InfinityDefault()
self.positiveInfinityDefault = monster.PositiveInfinityDefault()
self.negativeInfDefault = monster.NegativeInfDefault()
self.negativeInfinityDefault = monster.NegativeInfinityDefault()
self.doubleInfDefault = monster.DoubleInfDefault()
# MonsterT
def Pack(self, builder):
@@ -1582,5 +1678,13 @@ class MonsterT(object):
MonsterAddNativeInline(builder, nativeInline)
MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
MonsterAddNanDefault(builder, self.nanDefault)
MonsterAddInfDefault(builder, self.infDefault)
MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
MonsterAddInfinityDefault(builder, self.infinityDefault)
MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
monster = MonsterEnd(builder)
return monster

48
tests/MyGame/Example/MonsterT.java
View File

@@ -58,6 +58,14 @@ public class MonsterT {
private MyGame.Example.TestT nativeInline;
private long longEnumNonEnumDefault;
private long longEnumNormalDefault;
private float nanDefault;
private float infDefault;
private float positiveInfDefault;
private float infinityDefault;
private float positiveInfinityDefault;
private float negativeInfDefault;
private float negativeInfinityDefault;
private double doubleInfDefault;
public MyGame.Example.Vec3T getPos() { return pos; }
@@ -259,6 +267,38 @@ public class MonsterT {
public void setLongEnumNormalDefault(long longEnumNormalDefault) { this.longEnumNormalDefault = longEnumNormalDefault; }
public float getNanDefault() { return nanDefault; }
public void setNanDefault(float nanDefault) { this.nanDefault = nanDefault; }
public float getInfDefault() { return infDefault; }
public void setInfDefault(float infDefault) { this.infDefault = infDefault; }
public float getPositiveInfDefault() { return positiveInfDefault; }
public void setPositiveInfDefault(float positiveInfDefault) { this.positiveInfDefault = positiveInfDefault; }
public float getInfinityDefault() { return infinityDefault; }
public void setInfinityDefault(float infinityDefault) { this.infinityDefault = infinityDefault; }
public float getPositiveInfinityDefault() { return positiveInfinityDefault; }
public void setPositiveInfinityDefault(float positiveInfinityDefault) { this.positiveInfinityDefault = positiveInfinityDefault; }
public float getNegativeInfDefault() { return negativeInfDefault; }
public void setNegativeInfDefault(float negativeInfDefault) { this.negativeInfDefault = negativeInfDefault; }
public float getNegativeInfinityDefault() { return negativeInfinityDefault; }
public void setNegativeInfinityDefault(float negativeInfinityDefault) { this.negativeInfinityDefault = negativeInfinityDefault; }
public double getDoubleInfDefault() { return doubleInfDefault; }
public void setDoubleInfDefault(double doubleInfDefault) { this.doubleInfDefault = doubleInfDefault; }
public MonsterT() {
this.pos = new MyGame.Example.Vec3T();
@@ -311,6 +351,14 @@ public class MonsterT {
this.nativeInline = new MyGame.Example.TestT();
this.longEnumNonEnumDefault = 0L;
this.longEnumNormalDefault = 2L;
this.nanDefault = Float.NaN;
this.infDefault = Float.POSITIVE_INFINITY;
this.positiveInfDefault = Float.POSITIVE_INFINITY;
this.infinityDefault = Float.POSITIVE_INFINITY;
this.positiveInfinityDefault = Float.POSITIVE_INFINITY;
this.negativeInfDefault = Float.NEGATIVE_INFINITY;
this.negativeInfinityDefault = Float.NEGATIVE_INFINITY;
this.doubleInfDefault = Double.POSITIVE_INFINITY;
}
public static MonsterT deserializeFromBinary(byte[] fbBuffer) {
return Monster.getRootAsMonster(ByteBuffer.wrap(fbBuffer)).unpack();

222
tests/cpp17/generated_cpp17/monster_test_generated.h
View File

@@ -1321,6 +1321,14 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::Test native_inline{};
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne;
float nan_default = std::numeric_limits<float>::quiet_NaN();
float inf_default = std::numeric_limits<float>::infinity();
float positive_inf_default = std::numeric_limits<float>::infinity();
float infinity_default = std::numeric_limits<float>::infinity();
float positive_infinity_default = std::numeric_limits<float>::infinity();
float negative_inf_default = -std::numeric_limits<float>::infinity();
float negative_infinity_default = -std::numeric_limits<float>::infinity();
double double_inf_default = std::numeric_limits<double>::infinity();
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1388,7 +1396,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106,
VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
VT_LONG_ENUM_NORMAL_DEFAULT = 110
VT_LONG_ENUM_NORMAL_DEFAULT = 110,
VT_NAN_DEFAULT = 112,
VT_INF_DEFAULT = 114,
VT_POSITIVE_INF_DEFAULT = 116,
VT_INFINITY_DEFAULT = 118,
VT_POSITIVE_INFINITY_DEFAULT = 120,
VT_NEGATIVE_INF_DEFAULT = 122,
VT_NEGATIVE_INFINITY_DEFAULT = 124,
VT_DOUBLE_INF_DEFAULT = 126
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1745,6 +1761,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
}
float nan_default() const {
return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
}
bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
}
float inf_default() const {
return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
}
float positive_inf_default() const {
return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
}
float infinity_default() const {
return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
}
float positive_infinity_default() const {
return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
}
float negative_inf_default() const {
return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
}
float negative_infinity_default() const {
return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
}
double double_inf_default() const {
return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
}
bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
}
template<size_t Index>
auto get_field() const {
if constexpr (Index == 0) return pos();
@@ -1800,6 +1864,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
else if constexpr (Index == 50) return native_inline();
else if constexpr (Index == 51) return long_enum_non_enum_default();
else if constexpr (Index == 52) return long_enum_normal_default();
else if constexpr (Index == 53) return nan_default();
else if constexpr (Index == 54) return inf_default();
else if constexpr (Index == 55) return positive_inf_default();
else if constexpr (Index == 56) return infinity_default();
else if constexpr (Index == 57) return positive_infinity_default();
else if constexpr (Index == 58) return negative_inf_default();
else if constexpr (Index == 59) return negative_infinity_default();
else if constexpr (Index == 60) return double_inf_default();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
@@ -1893,6 +1965,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2087,6 +2167,30 @@ struct MonsterBuilder {
void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
}
void add_nan_default(float nan_default) {
fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
}
void add_inf_default(float inf_default) {
fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
}
void add_positive_inf_default(float positive_inf_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
}
void add_infinity_default(float infinity_default) {
fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
}
void add_positive_infinity_default(float positive_infinity_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
}
void add_negative_inf_default(float negative_inf_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
}
void add_negative_infinity_default(float negative_infinity_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
}
void add_double_inf_default(double double_inf_default) {
fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2153,8 +2257,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
MonsterBuilder builder_(_fbb);
builder_.add_double_inf_default(double_inf_default);
builder_.add_long_enum_normal_default(long_enum_normal_default);
builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
builder_.add_non_owning_reference(non_owning_reference);
@@ -2164,6 +2277,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
builder_.add_negative_infinity_default(negative_infinity_default);
builder_.add_negative_inf_default(negative_inf_default);
builder_.add_positive_infinity_default(positive_infinity_default);
builder_.add_infinity_default(infinity_default);
builder_.add_positive_inf_default(positive_inf_default);
builder_.add_inf_default(inf_default);
builder_.add_nan_default(nan_default);
builder_.add_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2216,7 +2336,7 @@ struct Monster::Traits {
static auto constexpr Create = CreateMonster;
static constexpr auto name = "Monster";
static constexpr auto fully_qualified_name = "MyGame.Example.Monster";
static constexpr size_t fields_number = 53;
static constexpr size_t fields_number = 61;
static constexpr std::array<const char *, fields_number> field_names = {
"pos",
"mana",
@@ -2270,7 +2390,15 @@ struct Monster::Traits {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
template<size_t Index>
using FieldType = decltype(std::declval<type>().get_field<Index>());
@@ -2330,7 +2458,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2406,7 +2542,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
scalar_key_sorted_tables__,
native_inline,
long_enum_non_enum_default,
long_enum_normal_default);
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2881,7 +3025,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline),
long_enum_non_enum_default(o.long_enum_non_enum_default),
long_enum_normal_default(o.long_enum_normal_default) {
long_enum_normal_default(o.long_enum_normal_default),
nan_default(o.nan_default),
inf_default(o.inf_default),
positive_inf_default(o.positive_inf_default),
infinity_default(o.infinity_default),
positive_infinity_default(o.positive_infinity_default),
negative_inf_default(o.negative_inf_default),
negative_infinity_default(o.negative_infinity_default),
double_inf_default(o.double_inf_default) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2945,6 +3097,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(native_inline, o.native_inline);
std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
std::swap(long_enum_normal_default, o.long_enum_normal_default);
std::swap(nan_default, o.nan_default);
std::swap(inf_default, o.inf_default);
std::swap(positive_inf_default, o.positive_inf_default);
std::swap(infinity_default, o.infinity_default);
std::swap(positive_infinity_default, o.positive_infinity_default);
std::swap(negative_inf_default, o.negative_inf_default);
std::swap(negative_infinity_default, o.negative_infinity_default);
std::swap(double_inf_default, o.double_inf_default);
return *this;
}
@@ -3010,6 +3170,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
{ auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
{ auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
{ auto _e = nan_default(); _o->nan_default = _e; }
{ auto _e = inf_default(); _o->inf_default = _e; }
{ auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
{ auto _e = infinity_default(); _o->infinity_default = _e; }
{ auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
{ auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
{ auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
{ auto _e = double_inf_default(); _o->double_inf_default = _e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3073,6 +3241,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _native_inline = &_o->native_inline;
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
auto _long_enum_normal_default = _o->long_enum_normal_default;
auto _nan_default = _o->nan_default;
auto _inf_default = _o->inf_default;
auto _positive_inf_default = _o->positive_inf_default;
auto _infinity_default = _o->infinity_default;
auto _positive_infinity_default = _o->positive_infinity_default;
auto _negative_inf_default = _o->negative_inf_default;
auto _negative_infinity_default = _o->negative_infinity_default;
auto _double_inf_default = _o->double_inf_default;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -3127,7 +3303,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_scalar_key_sorted_tables,
_native_inline,
_long_enum_non_enum_default,
_long_enum_normal_default);
_long_enum_normal_default,
_nan_default,
_inf_default,
_positive_inf_default,
_infinity_default,
_positive_infinity_default,
_negative_inf_default,
_negative_infinity_default,
_double_inf_default);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3885,7 +4069,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_ULONG, 0, 12 }
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3956,10 +4148,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

8
tests/cpp17/test_cpp17.cpp
View File

@@ -148,6 +148,14 @@ void StringifyAnyFlatbuffersTypeTest() {
signed_enum = -1
long_enum_non_enum_default = 0
long_enum_normal_default = 2
nan_default = nan
inf_default = inf
positive_inf_default = inf
infinity_default = inf
positive_infinity_default = inf
negative_inf_default = -inf
negative_infinity_default = -inf
double_inf_default = inf
})";
// Call a generic function that has no specific knowledge of the flatbuffer we

8
tests/go_test.go
View File

@@ -533,6 +533,14 @@ func CheckObjectAPI(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fa
fail(FailString("mana", 150, got))
}
if monster.Test != nil && monster.Test.Type == example.AnyMonster {
monster.Test.Value.(*example.MonsterT).NanDefault = 0.0
}
if monster.Enemy != nil {
monster.Enemy.NanDefault = 0.0
}
monster.NanDefault = 0.0
builder := flatbuffers.NewBuilder(0)
builder.Finish(monster.Pack(builder))
monster2 := example.GetRootAsMonster(builder.FinishedBytes(), 0).UnPack()

8276
tests/monster_test.afb
View File

File diff suppressed because it is too large Load Diff

BIN
tests/monster_test.bfbs
View File

Binary file not shown.

9
tests/monster_test.fbs
View File

@@ -141,6 +141,15 @@ table Monster {
// enum value.
long_enum_non_enum_default:LongEnum (id: 52);
long_enum_normal_default:LongEnum = LongOne (id: 53);
// Test that default values nan and +/-inf work.
nan_default:float = nan (id: 54);
inf_default:float = inf (id: 55);
positive_inf_default:float = +inf (id: 56);
infinity_default:float = infinity (id: 57);
positive_infinity_default:float = +infinity (id: 58);
negative_inf_default:float = -inf (id: 59);
negative_infinity_default:float = -infinity (id: 60);
double_inf_default:double = inf (id: 61);
}
table TypeAliases {

24
tests/monster_test.schema.json
View File

@@ -340,6 +340,30 @@
},
"long_enum_normal_default" : {
"$ref" : "#/definitions/MyGame_Example_LongEnum"
},
"nan_default" : {
"type" : "number"
},
"inf_default" : {
"type" : "number"
},
"positive_inf_default" : {
"type" : "number"
},
"infinity_default" : {
"type" : "number"
},
"positive_infinity_default" : {
"type" : "number"
},
"negative_inf_default" : {
"type" : "number"
},
"negative_infinity_default" : {
"type" : "number"
},
"double_inf_default" : {
"type" : "number"
}
},
"required" : ["name"],

184
tests/monster_test/my_game/example/monster_generated.rs
View File

@@ -79,6 +79,14 @@ impl<'a> Monster<'a> {
pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: flatbuffers::VOffsetT = 108;
pub const VT_LONG_ENUM_NORMAL_DEFAULT: flatbuffers::VOffsetT = 110;
pub const VT_NAN_DEFAULT: flatbuffers::VOffsetT = 112;
pub const VT_INF_DEFAULT: flatbuffers::VOffsetT = 114;
pub const VT_POSITIVE_INF_DEFAULT: flatbuffers::VOffsetT = 116;
pub const VT_INFINITY_DEFAULT: flatbuffers::VOffsetT = 118;
pub const VT_POSITIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 120;
pub const VT_NEGATIVE_INF_DEFAULT: flatbuffers::VOffsetT = 122;
pub const VT_NEGATIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 124;
pub const VT_DOUBLE_INF_DEFAULT: flatbuffers::VOffsetT = 126;
pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Monster"
@@ -94,6 +102,7 @@ impl<'a> Monster<'a> {
args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb);
builder.add_double_inf_default(args.double_inf_default);
builder.add_long_enum_normal_default(args.long_enum_normal_default);
builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default);
builder.add_non_owning_reference(args.non_owning_reference);
@@ -103,6 +112,13 @@ impl<'a> Monster<'a> {
builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
builder.add_negative_infinity_default(args.negative_infinity_default);
builder.add_negative_inf_default(args.negative_inf_default);
builder.add_positive_infinity_default(args.positive_infinity_default);
builder.add_infinity_default(args.infinity_default);
builder.add_positive_inf_default(args.positive_inf_default);
builder.add_inf_default(args.inf_default);
builder.add_nan_default(args.nan_default);
if let Some(x) = args.native_inline { builder.add_native_inline(x); }
if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); }
if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
@@ -308,6 +324,14 @@ impl<'a> Monster<'a> {
});
let long_enum_non_enum_default = self.long_enum_non_enum_default();
let long_enum_normal_default = self.long_enum_normal_default();
let nan_default = self.nan_default();
let inf_default = self.inf_default();
let positive_inf_default = self.positive_inf_default();
let infinity_default = self.infinity_default();
let positive_infinity_default = self.positive_infinity_default();
let negative_inf_default = self.negative_inf_default();
let negative_infinity_default = self.negative_infinity_default();
let double_inf_default = self.double_inf_default();
MonsterT {
pos,
mana,
@@ -359,6 +383,14 @@ impl<'a> Monster<'a> {
native_inline,
long_enum_non_enum_default,
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default,
}
}
@@ -764,6 +796,62 @@ impl<'a> Monster<'a> {
unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()}
}
#[inline]
pub fn nan_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()}
}
#[inline]
pub fn inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn positive_inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn positive_infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn negative_inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
}
#[inline]
pub fn negative_infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
}
#[inline]
pub fn double_inf_default(&self) -> f64 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()}
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -978,6 +1066,14 @@ impl flatbuffers::Verifiable for Monster<'_> {
.visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
.visit_field::<LongEnum>("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)?
.visit_field::<LongEnum>("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)?
.visit_field::<f32>("nan_default", Self::VT_NAN_DEFAULT, false)?
.visit_field::<f32>("inf_default", Self::VT_INF_DEFAULT, false)?
.visit_field::<f32>("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)?
.visit_field::<f32>("infinity_default", Self::VT_INFINITY_DEFAULT, false)?
.visit_field::<f32>("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)?
.visit_field::<f32>("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)?
.visit_field::<f32>("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)?
.visit_field::<f64>("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)?
.finish();
Ok(())
}
@@ -1036,6 +1132,14 @@ pub struct MonsterArgs<'a> {
pub native_inline: Option<&'a Test>,
pub long_enum_non_enum_default: LongEnum,
pub long_enum_normal_default: LongEnum,
pub nan_default: f32,
pub inf_default: f32,
pub positive_inf_default: f32,
pub infinity_default: f32,
pub positive_infinity_default: f32,
pub negative_inf_default: f32,
pub negative_infinity_default: f32,
pub double_inf_default: f64,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -1094,6 +1198,14 @@ impl<'a> Default for MonsterArgs<'a> {
native_inline: None,
long_enum_non_enum_default: Default::default(),
long_enum_normal_default: LongEnum::LongOne,
nan_default: f32::NAN,
inf_default: f32::INFINITY,
positive_inf_default: f32::INFINITY,
infinity_default: f32::INFINITY,
positive_infinity_default: f32::INFINITY,
negative_inf_default: f32::NEG_INFINITY,
negative_infinity_default: f32::NEG_INFINITY,
double_inf_default: f64::INFINITY,
}
}
}
@@ -1316,6 +1428,38 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
}
#[inline]
pub fn add_nan_default(&mut self, nan_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN);
}
#[inline]
pub fn add_inf_default(&mut self, inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY);
}
#[inline]
pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY);
}
#[inline]
pub fn add_infinity_default(&mut self, infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY);
}
#[inline]
pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY);
}
#[inline]
pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY);
}
#[inline]
pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY);
}
#[inline]
pub fn add_double_inf_default(&mut self, double_inf_default: f64) {
self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -1465,6 +1609,14 @@ impl core::fmt::Debug for Monster<'_> {
ds.field("native_inline", &self.native_inline());
ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default());
ds.field("long_enum_normal_default", &self.long_enum_normal_default());
ds.field("nan_default", &self.nan_default());
ds.field("inf_default", &self.inf_default());
ds.field("positive_inf_default", &self.positive_inf_default());
ds.field("infinity_default", &self.infinity_default());
ds.field("positive_infinity_default", &self.positive_infinity_default());
ds.field("negative_inf_default", &self.negative_inf_default());
ds.field("negative_infinity_default", &self.negative_infinity_default());
ds.field("double_inf_default", &self.double_inf_default());
ds.finish()
}
}
@@ -1521,6 +1673,14 @@ pub struct MonsterT {
pub native_inline: Option<TestT>,
pub long_enum_non_enum_default: LongEnum,
pub long_enum_normal_default: LongEnum,
pub nan_default: f32,
pub inf_default: f32,
pub positive_inf_default: f32,
pub infinity_default: f32,
pub positive_infinity_default: f32,
pub negative_inf_default: f32,
pub negative_infinity_default: f32,
pub double_inf_default: f64,
}
impl Default for MonsterT {
fn default() -> Self {
@@ -1575,6 +1735,14 @@ impl Default for MonsterT {
native_inline: None,
long_enum_non_enum_default: Default::default(),
long_enum_normal_default: LongEnum::LongOne,
nan_default: f32::NAN,
inf_default: f32::INFINITY,
positive_inf_default: f32::INFINITY,
infinity_default: f32::INFINITY,
positive_infinity_default: f32::INFINITY,
negative_inf_default: f32::NEG_INFINITY,
negative_infinity_default: f32::NEG_INFINITY,
double_inf_default: f64::INFINITY,
}
}
}
@@ -1687,6 +1855,14 @@ impl MonsterT {
let native_inline = native_inline_tmp.as_ref();
let long_enum_non_enum_default = self.long_enum_non_enum_default;
let long_enum_normal_default = self.long_enum_normal_default;
let nan_default = self.nan_default;
let inf_default = self.inf_default;
let positive_inf_default = self.positive_inf_default;
let infinity_default = self.infinity_default;
let positive_infinity_default = self.positive_infinity_default;
let negative_inf_default = self.negative_inf_default;
let negative_infinity_default = self.negative_infinity_default;
let double_inf_default = self.double_inf_default;
Monster::create(_fbb, &MonsterArgs{
pos,
mana,
@@ -1741,6 +1917,14 @@ impl MonsterT {
native_inline,
long_enum_non_enum_default,
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default,
})
}
}

1247
tests/monster_test_bfbs_generated.h
View File

File diff suppressed because it is too large Load Diff

212
tests/monster_test_generated.h
View File

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::Test native_inline{};
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
float nan_default = std::numeric_limits<float>::quiet_NaN();
float inf_default = std::numeric_limits<float>::infinity();
float positive_inf_default = std::numeric_limits<float>::infinity();
float infinity_default = std::numeric_limits<float>::infinity();
float positive_infinity_default = std::numeric_limits<float>::infinity();
float negative_inf_default = -std::numeric_limits<float>::infinity();
float negative_infinity_default = -std::numeric_limits<float>::infinity();
double double_inf_default = std::numeric_limits<double>::infinity();
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106,
VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
VT_LONG_ENUM_NORMAL_DEFAULT = 110
VT_LONG_ENUM_NORMAL_DEFAULT = 110,
VT_NAN_DEFAULT = 112,
VT_INF_DEFAULT = 114,
VT_POSITIVE_INF_DEFAULT = 116,
VT_INFINITY_DEFAULT = 118,
VT_POSITIVE_INFINITY_DEFAULT = 120,
VT_NEGATIVE_INF_DEFAULT = 122,
VT_NEGATIVE_INFINITY_DEFAULT = 124,
VT_DOUBLE_INF_DEFAULT = 126
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
}
float nan_default() const {
return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
}
bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
}
float inf_default() const {
return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
}
float positive_inf_default() const {
return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
}
float infinity_default() const {
return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
}
float positive_infinity_default() const {
return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
}
float negative_inf_default() const {
return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
}
float negative_infinity_default() const {
return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
}
double double_inf_default() const {
return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
}
bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
}
void add_nan_default(float nan_default) {
fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
}
void add_inf_default(float inf_default) {
fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
}
void add_positive_inf_default(float positive_inf_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
}
void add_infinity_default(float infinity_default) {
fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
}
void add_positive_infinity_default(float positive_infinity_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
}
void add_negative_inf_default(float negative_inf_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
}
void add_negative_infinity_default(float negative_infinity_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
}
void add_double_inf_default(double double_inf_default) {
fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
MonsterBuilder builder_(_fbb);
builder_.add_double_inf_default(double_inf_default);
builder_.add_long_enum_normal_default(long_enum_normal_default);
builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
builder_.add_negative_infinity_default(negative_infinity_default);
builder_.add_negative_inf_default(negative_inf_default);
builder_.add_positive_infinity_default(positive_infinity_default);
builder_.add_infinity_default(infinity_default);
builder_.add_positive_inf_default(positive_inf_default);
builder_.add_inf_default(inf_default);
builder_.add_nan_default(nan_default);
builder_.add_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
scalar_key_sorted_tables__,
native_inline,
long_enum_non_enum_default,
long_enum_normal_default);
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
(lhs.native_inline == rhs.native_inline) &&
(lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
(lhs.long_enum_normal_default == rhs.long_enum_normal_default);
(lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
(lhs.nan_default == rhs.nan_default) &&
(lhs.inf_default == rhs.inf_default) &&
(lhs.positive_inf_default == rhs.positive_inf_default) &&
(lhs.infinity_default == rhs.infinity_default) &&
(lhs.positive_infinity_default == rhs.positive_infinity_default) &&
(lhs.negative_inf_default == rhs.negative_inf_default) &&
(lhs.negative_infinity_default == rhs.negative_infinity_default) &&
(lhs.double_inf_default == rhs.double_inf_default);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline),
long_enum_non_enum_default(o.long_enum_non_enum_default),
long_enum_normal_default(o.long_enum_normal_default) {
long_enum_normal_default(o.long_enum_normal_default),
nan_default(o.nan_default),
inf_default(o.inf_default),
positive_inf_default(o.positive_inf_default),
infinity_default(o.infinity_default),
positive_infinity_default(o.positive_infinity_default),
negative_inf_default(o.negative_inf_default),
negative_infinity_default(o.negative_infinity_default),
double_inf_default(o.double_inf_default) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(native_inline, o.native_inline);
std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
std::swap(long_enum_normal_default, o.long_enum_normal_default);
std::swap(nan_default, o.nan_default);
std::swap(inf_default, o.inf_default);
std::swap(positive_inf_default, o.positive_inf_default);
std::swap(infinity_default, o.infinity_default);
std::swap(positive_infinity_default, o.positive_infinity_default);
std::swap(negative_inf_default, o.negative_inf_default);
std::swap(negative_infinity_default, o.negative_infinity_default);
std::swap(double_inf_default, o.double_inf_default);
return *this;
}
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
{ auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
{ auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
{ auto _e = nan_default(); _o->nan_default = _e; }
{ auto _e = inf_default(); _o->inf_default = _e; }
{ auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
{ auto _e = infinity_default(); _o->infinity_default = _e; }
{ auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
{ auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
{ auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
{ auto _e = double_inf_default(); _o->double_inf_default = _e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _native_inline = &_o->native_inline;
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
auto _long_enum_normal_default = _o->long_enum_normal_default;
auto _nan_default = _o->nan_default;
auto _inf_default = _o->inf_default;
auto _positive_inf_default = _o->positive_inf_default;
auto _infinity_default = _o->infinity_default;
auto _positive_infinity_default = _o->positive_infinity_default;
auto _negative_inf_default = _o->negative_inf_default;
auto _negative_infinity_default = _o->negative_infinity_default;
auto _double_inf_default = _o->double_inf_default;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_scalar_key_sorted_tables,
_native_inline,
_long_enum_non_enum_default,
_long_enum_normal_default);
_long_enum_normal_default,
_nan_default,
_inf_default,
_positive_inf_default,
_infinity_default,
_positive_infinity_default,
_negative_inf_default,
_negative_infinity_default,
_double_inf_default);
}
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_ULONG, 0, 12 }
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

42
tests/monster_test_generated.lobster
View File

@@ -425,13 +425,29 @@ class Monster : flatbuffers_handle
return LongEnum(buf_.flatbuffers_field_uint64(pos_, 108, 0))
def long_enum_normal_default() -> LongEnum:
return LongEnum(buf_.flatbuffers_field_uint64(pos_, 110, 2))
def nan_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 112, nan)
def inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 114, inf)
def positive_inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 116, +inf)
def infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 118, infinity)
def positive_infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 120, +infinity)
def negative_inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 122, -inf)
def negative_infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 124, -infinity)
def double_inf_default() -> float:
return buf_.flatbuffers_field_float64(pos_, 126, inf)
def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
struct MonsterBuilder:
b_:flatbuffers_builder
def start():
b_.StartObject(54)
b_.StartObject(62)
return this
def add_pos(pos:flatbuffers_offset):
b_.PrependStructSlot(0, pos)
@@ -592,6 +608,30 @@ struct MonsterBuilder:
def add_long_enum_normal_default(long_enum_normal_default:LongEnum):
b_.PrependUint64Slot(53, long_enum_normal_default, 2)
return this
def add_nan_default(nan_default:float):
b_.PrependFloat32Slot(54, nan_default, nan)
return this
def add_inf_default(inf_default:float):
b_.PrependFloat32Slot(55, inf_default, inf)
return this
def add_positive_inf_default(positive_inf_default:float):
b_.PrependFloat32Slot(56, positive_inf_default, +inf)
return this
def add_infinity_default(infinity_default:float):
b_.PrependFloat32Slot(57, infinity_default, infinity)
return this
def add_positive_infinity_default(positive_infinity_default:float):
b_.PrependFloat32Slot(58, positive_infinity_default, +infinity)
return this
def add_negative_inf_default(negative_inf_default:float):
b_.PrependFloat32Slot(59, negative_inf_default, -inf)
return this
def add_negative_infinity_default(negative_infinity_default:float):
b_.PrependFloat32Slot(60, negative_infinity_default, -infinity)
return this
def add_double_inf_default(double_inf_default:float):
b_.PrependFloat64Slot(61, double_inf_default, inf)
return this
def end():
return b_.EndObject()

90
tests/monster_test_generated.py
View File

@@ -1615,7 +1615,63 @@ class Monster(object):
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 2
def MonsterStart(builder): builder.StartObject(54)
# Monster
def NanDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('nan')
# Monster
def InfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def PositiveInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def InfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def PositiveInfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('inf')
# Monster
def NegativeInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('-inf')
# Monster
def NegativeInfinityDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
return float('-inf')
# Monster
def DoubleInfDefault(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
return float('inf')
def MonsterStart(builder): builder.StartObject(62)
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
@@ -1699,6 +1755,14 @@ def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.S
def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
def MonsterEnd(builder): return builder.EndObject()
try:
@@ -1763,6 +1827,14 @@ class MonsterT(object):
self.nativeInline = None # type: Optional[TestT]
self.longEnumNonEnumDefault = 0 # type: int
self.longEnumNormalDefault = 2 # type: int
self.nanDefault = float('nan') # type: float
self.infDefault = float('inf') # type: float
self.positiveInfDefault = float('inf') # type: float
self.infinityDefault = float('inf') # type: float
self.positiveInfinityDefault = float('inf') # type: float
self.negativeInfDefault = float('-inf') # type: float
self.negativeInfinityDefault = float('-inf') # type: float
self.doubleInfDefault = float('inf') # type: float
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1964,6 +2036,14 @@ class MonsterT(object):
self.nativeInline = TestT.InitFromObj(monster.NativeInline())
self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
self.longEnumNormalDefault = monster.LongEnumNormalDefault()
self.nanDefault = monster.NanDefault()
self.infDefault = monster.InfDefault()
self.positiveInfDefault = monster.PositiveInfDefault()
self.infinityDefault = monster.InfinityDefault()
self.positiveInfinityDefault = monster.PositiveInfinityDefault()
self.negativeInfDefault = monster.NegativeInfDefault()
self.negativeInfinityDefault = monster.NegativeInfinityDefault()
self.doubleInfDefault = monster.DoubleInfDefault()
# MonsterT
def Pack(self, builder):
@@ -2217,6 +2297,14 @@ class MonsterT(object):
MonsterAddNativeInline(builder, nativeInline)
MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
MonsterAddNanDefault(builder, self.nanDefault)
MonsterAddInfDefault(builder, self.infDefault)
MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
MonsterAddInfinityDefault(builder, self.infinityDefault)
MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
monster = MonsterEnd(builder)
return monster

120
tests/monster_test_my_game.example_generated.dart
View File

@@ -1258,10 +1258,18 @@ class Monster {
Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0));
LongEnum get longEnumNormalDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2));
double get nanDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
double get infDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);
double get positiveInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);
double get infinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);
double get positiveInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
double get negativeInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 122, double.negativeInfinity);
double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 124, double.negativeInfinity);
double get doubleInfDefault => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
@override
String toString() {
return 'Monster{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}}';
return 'Monster{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
}
MonsterT unpack() => MonsterT(
@@ -1317,7 +1325,15 @@ class Monster {
scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList(),
nativeInline: nativeInline?.unpack(),
longEnumNonEnumDefault: longEnumNonEnumDefault,
longEnumNormalDefault: longEnumNormalDefault);
longEnumNormalDefault: longEnumNormalDefault,
nanDefault: nanDefault,
infDefault: infDefault,
positiveInfDefault: positiveInfDefault,
infinityDefault: infinityDefault,
positiveInfinityDefault: positiveInfinityDefault,
negativeInfDefault: negativeInfDefault,
negativeInfinityDefault: negativeInfinityDefault,
doubleInfDefault: doubleInfDefault);
static int pack(fb.Builder fbBuilder, MonsterT? object) {
if (object == null) return 0;
@@ -1382,6 +1398,14 @@ class MonsterT implements fb.Packable {
TestT? nativeInline;
LongEnum longEnumNonEnumDefault;
LongEnum longEnumNormalDefault;
double nanDefault;
double infDefault;
double positiveInfDefault;
double infinityDefault;
double positiveInfinityDefault;
double negativeInfDefault;
double negativeInfinityDefault;
double doubleInfDefault;
MonsterT({
this.pos,
@@ -1436,7 +1460,15 @@ class MonsterT implements fb.Packable {
this.scalarKeySortedTables,
this.nativeInline,
this.longEnumNonEnumDefault = const LongEnum._(0),
this.longEnumNormalDefault = LongEnum.LongOne});
this.longEnumNormalDefault = LongEnum.LongOne,
this.nanDefault = double.nan,
this.infDefault = double.infinity,
this.positiveInfDefault = double.infinity,
this.infinityDefault = double.infinity,
this.positiveInfinityDefault = double.infinity,
this.negativeInfDefault = double.negativeInfinity,
this.negativeInfinityDefault = double.negativeInfinity,
this.doubleInfDefault = double.infinity});
@override
int pack(fb.Builder fbBuilder) {
@@ -1497,7 +1529,7 @@ class MonsterT implements fb.Packable {
: fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null ? null
: fbBuilder.writeList(scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList());
fbBuilder.startTable(54);
fbBuilder.startTable(62);
if (pos != null) {
fbBuilder.addStruct(0, pos!.pack(fbBuilder));
}
@@ -1555,12 +1587,20 @@ class MonsterT implements fb.Packable {
}
fbBuilder.addUint64(52, longEnumNonEnumDefault.value);
fbBuilder.addUint64(53, longEnumNormalDefault.value);
fbBuilder.addFloat32(54, nanDefault);
fbBuilder.addFloat32(55, infDefault);
fbBuilder.addFloat32(56, positiveInfDefault);
fbBuilder.addFloat32(57, infinityDefault);
fbBuilder.addFloat32(58, positiveInfinityDefault);
fbBuilder.addFloat32(59, negativeInfDefault);
fbBuilder.addFloat32(60, negativeInfinityDefault);
fbBuilder.addFloat64(61, doubleInfDefault);
return fbBuilder.endTable();
}
@override
String toString() {
return 'MonsterT{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}}';
return 'MonsterT{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
}
}
@@ -1578,7 +1618,7 @@ class MonsterBuilder {
final fb.Builder fbBuilder;
void begin() {
fbBuilder.startTable(54);
fbBuilder.startTable(62);
}
int addPos(int offset) {
@@ -1793,6 +1833,38 @@ class MonsterBuilder {
fbBuilder.addUint64(53, longEnumNormalDefault?.value);
return fbBuilder.offset;
}
int addNanDefault(double? nanDefault) {
fbBuilder.addFloat32(54, nanDefault);
return fbBuilder.offset;
}
int addInfDefault(double? infDefault) {
fbBuilder.addFloat32(55, infDefault);
return fbBuilder.offset;
}
int addPositiveInfDefault(double? positiveInfDefault) {
fbBuilder.addFloat32(56, positiveInfDefault);
return fbBuilder.offset;
}
int addInfinityDefault(double? infinityDefault) {
fbBuilder.addFloat32(57, infinityDefault);
return fbBuilder.offset;
}
int addPositiveInfinityDefault(double? positiveInfinityDefault) {
fbBuilder.addFloat32(58, positiveInfinityDefault);
return fbBuilder.offset;
}
int addNegativeInfDefault(double? negativeInfDefault) {
fbBuilder.addFloat32(59, negativeInfDefault);
return fbBuilder.offset;
}
int addNegativeInfinityDefault(double? negativeInfinityDefault) {
fbBuilder.addFloat32(60, negativeInfinityDefault);
return fbBuilder.offset;
}
int addDoubleInfDefault(double? doubleInfDefault) {
fbBuilder.addFloat64(61, doubleInfDefault);
return fbBuilder.offset;
}
int finish() {
return fbBuilder.endTable();
@@ -1853,6 +1925,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final TestObjectBuilder? _nativeInline;
final LongEnum? _longEnumNonEnumDefault;
final LongEnum? _longEnumNormalDefault;
final double? _nanDefault;
final double? _infDefault;
final double? _positiveInfDefault;
final double? _infinityDefault;
final double? _positiveInfinityDefault;
final double? _negativeInfDefault;
final double? _negativeInfinityDefault;
final double? _doubleInfDefault;
MonsterObjectBuilder({
Vec3ObjectBuilder? pos,
@@ -1908,6 +1988,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
TestObjectBuilder? nativeInline,
LongEnum? longEnumNonEnumDefault,
LongEnum? longEnumNormalDefault,
double? nanDefault,
double? infDefault,
double? positiveInfDefault,
double? infinityDefault,
double? positiveInfinityDefault,
double? negativeInfDefault,
double? negativeInfinityDefault,
double? doubleInfDefault,
})
: _pos = pos,
_mana = mana,
@@ -1961,7 +2049,15 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
_scalarKeySortedTables = scalarKeySortedTables,
_nativeInline = nativeInline,
_longEnumNonEnumDefault = longEnumNonEnumDefault,
_longEnumNormalDefault = longEnumNormalDefault;
_longEnumNormalDefault = longEnumNormalDefault,
_nanDefault = nanDefault,
_infDefault = infDefault,
_positiveInfDefault = positiveInfDefault,
_infinityDefault = infinityDefault,
_positiveInfinityDefault = positiveInfinityDefault,
_negativeInfDefault = negativeInfDefault,
_negativeInfinityDefault = negativeInfinityDefault,
_doubleInfDefault = doubleInfDefault;
/// Finish building, and store into the [fbBuilder].
@override
@@ -2014,7 +2110,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
: fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null ? null
: fbBuilder.writeList(_scalarKeySortedTables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
fbBuilder.startTable(54);
fbBuilder.startTable(62);
if (_pos != null) {
fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
}
@@ -2072,6 +2168,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
}
fbBuilder.addUint64(52, _longEnumNonEnumDefault?.value);
fbBuilder.addUint64(53, _longEnumNormalDefault?.value);
fbBuilder.addFloat32(54, _nanDefault);
fbBuilder.addFloat32(55, _infDefault);
fbBuilder.addFloat32(56, _positiveInfDefault);
fbBuilder.addFloat32(57, _infinityDefault);
fbBuilder.addFloat32(58, _positiveInfinityDefault);
fbBuilder.addFloat32(59, _negativeInfDefault);
fbBuilder.addFloat32(60, _negativeInfinityDefault);
fbBuilder.addFloat64(61, _doubleInfDefault);
return fbBuilder.endTable();
}

194
tests/monster_test_serialize/my_game/example/monster_generated.rs
View File

@@ -81,6 +81,14 @@ impl<'a> Monster<'a> {
pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: flatbuffers::VOffsetT = 108;
pub const VT_LONG_ENUM_NORMAL_DEFAULT: flatbuffers::VOffsetT = 110;
pub const VT_NAN_DEFAULT: flatbuffers::VOffsetT = 112;
pub const VT_INF_DEFAULT: flatbuffers::VOffsetT = 114;
pub const VT_POSITIVE_INF_DEFAULT: flatbuffers::VOffsetT = 116;
pub const VT_INFINITY_DEFAULT: flatbuffers::VOffsetT = 118;
pub const VT_POSITIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 120;
pub const VT_NEGATIVE_INF_DEFAULT: flatbuffers::VOffsetT = 122;
pub const VT_NEGATIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 124;
pub const VT_DOUBLE_INF_DEFAULT: flatbuffers::VOffsetT = 126;
pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Monster"
@@ -96,6 +104,7 @@ impl<'a> Monster<'a> {
args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb);
builder.add_double_inf_default(args.double_inf_default);
builder.add_long_enum_normal_default(args.long_enum_normal_default);
builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default);
builder.add_non_owning_reference(args.non_owning_reference);
@@ -105,6 +114,13 @@ impl<'a> Monster<'a> {
builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
builder.add_negative_infinity_default(args.negative_infinity_default);
builder.add_negative_inf_default(args.negative_inf_default);
builder.add_positive_infinity_default(args.positive_infinity_default);
builder.add_infinity_default(args.infinity_default);
builder.add_positive_inf_default(args.positive_inf_default);
builder.add_inf_default(args.inf_default);
builder.add_nan_default(args.nan_default);
if let Some(x) = args.native_inline { builder.add_native_inline(x); }
if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); }
if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
@@ -310,6 +326,14 @@ impl<'a> Monster<'a> {
});
let long_enum_non_enum_default = self.long_enum_non_enum_default();
let long_enum_normal_default = self.long_enum_normal_default();
let nan_default = self.nan_default();
let inf_default = self.inf_default();
let positive_inf_default = self.positive_inf_default();
let infinity_default = self.infinity_default();
let positive_infinity_default = self.positive_infinity_default();
let negative_inf_default = self.negative_inf_default();
let negative_infinity_default = self.negative_infinity_default();
let double_inf_default = self.double_inf_default();
MonsterT {
pos,
mana,
@@ -361,6 +385,14 @@ impl<'a> Monster<'a> {
native_inline,
long_enum_non_enum_default,
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default,
}
}
@@ -766,6 +798,62 @@ impl<'a> Monster<'a> {
unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()}
}
#[inline]
pub fn nan_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()}
}
#[inline]
pub fn inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn positive_inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn positive_infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
}
#[inline]
pub fn negative_inf_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
}
#[inline]
pub fn negative_infinity_default(&self) -> f32 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
}
#[inline]
pub fn double_inf_default(&self) -> f64 {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()}
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -980,6 +1068,14 @@ impl flatbuffers::Verifiable for Monster<'_> {
.visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
.visit_field::<LongEnum>("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)?
.visit_field::<LongEnum>("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)?
.visit_field::<f32>("nan_default", Self::VT_NAN_DEFAULT, false)?
.visit_field::<f32>("inf_default", Self::VT_INF_DEFAULT, false)?
.visit_field::<f32>("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)?
.visit_field::<f32>("infinity_default", Self::VT_INFINITY_DEFAULT, false)?
.visit_field::<f32>("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)?
.visit_field::<f32>("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)?
.visit_field::<f32>("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)?
.visit_field::<f64>("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)?
.finish();
Ok(())
}
@@ -1038,6 +1134,14 @@ pub struct MonsterArgs<'a> {
pub native_inline: Option<&'a Test>,
pub long_enum_non_enum_default: LongEnum,
pub long_enum_normal_default: LongEnum,
pub nan_default: f32,
pub inf_default: f32,
pub positive_inf_default: f32,
pub infinity_default: f32,
pub positive_infinity_default: f32,
pub negative_inf_default: f32,
pub negative_infinity_default: f32,
pub double_inf_default: f64,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -1096,6 +1200,14 @@ impl<'a> Default for MonsterArgs<'a> {
native_inline: None,
long_enum_non_enum_default: Default::default(),
long_enum_normal_default: LongEnum::LongOne,
nan_default: f32::NAN,
inf_default: f32::INFINITY,
positive_inf_default: f32::INFINITY,
infinity_default: f32::INFINITY,
positive_infinity_default: f32::INFINITY,
negative_inf_default: f32::NEG_INFINITY,
negative_infinity_default: f32::NEG_INFINITY,
double_inf_default: f64::INFINITY,
}
}
}
@@ -1105,7 +1217,7 @@ impl Serialize for Monster<'_> {
where
S: Serializer,
{
let mut s = serializer.serialize_struct("Monster", 54)?;
let mut s = serializer.serialize_struct("Monster", 62)?;
if let Some(f) = self.pos() {
s.serialize_field("pos", &f)?;
} else {
@@ -1313,6 +1425,14 @@ impl Serialize for Monster<'_> {
}
s.serialize_field("long_enum_non_enum_default", &self.long_enum_non_enum_default())?;
s.serialize_field("long_enum_normal_default", &self.long_enum_normal_default())?;
s.serialize_field("nan_default", &self.nan_default())?;
s.serialize_field("inf_default", &self.inf_default())?;
s.serialize_field("positive_inf_default", &self.positive_inf_default())?;
s.serialize_field("infinity_default", &self.infinity_default())?;
s.serialize_field("positive_infinity_default", &self.positive_infinity_default())?;
s.serialize_field("negative_inf_default", &self.negative_inf_default())?;
s.serialize_field("negative_infinity_default", &self.negative_infinity_default())?;
s.serialize_field("double_inf_default", &self.double_inf_default())?;
s.end()
}
}
@@ -1535,6 +1655,38 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
}
#[inline]
pub fn add_nan_default(&mut self, nan_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN);
}
#[inline]
pub fn add_inf_default(&mut self, inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY);
}
#[inline]
pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY);
}
#[inline]
pub fn add_infinity_default(&mut self, infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY);
}
#[inline]
pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY);
}
#[inline]
pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY);
}
#[inline]
pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) {
self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY);
}
#[inline]
pub fn add_double_inf_default(&mut self, double_inf_default: f64) {
self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -1684,6 +1836,14 @@ impl core::fmt::Debug for Monster<'_> {
ds.field("native_inline", &self.native_inline());
ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default());
ds.field("long_enum_normal_default", &self.long_enum_normal_default());
ds.field("nan_default", &self.nan_default());
ds.field("inf_default", &self.inf_default());
ds.field("positive_inf_default", &self.positive_inf_default());
ds.field("infinity_default", &self.infinity_default());
ds.field("positive_infinity_default", &self.positive_infinity_default());
ds.field("negative_inf_default", &self.negative_inf_default());
ds.field("negative_infinity_default", &self.negative_infinity_default());
ds.field("double_inf_default", &self.double_inf_default());
ds.finish()
}
}
@@ -1740,6 +1900,14 @@ pub struct MonsterT {
pub native_inline: Option<TestT>,
pub long_enum_non_enum_default: LongEnum,
pub long_enum_normal_default: LongEnum,
pub nan_default: f32,
pub inf_default: f32,
pub positive_inf_default: f32,
pub infinity_default: f32,
pub positive_infinity_default: f32,
pub negative_inf_default: f32,
pub negative_infinity_default: f32,
pub double_inf_default: f64,
}
impl Default for MonsterT {
fn default() -> Self {
@@ -1794,6 +1962,14 @@ impl Default for MonsterT {
native_inline: None,
long_enum_non_enum_default: Default::default(),
long_enum_normal_default: LongEnum::LongOne,
nan_default: f32::NAN,
inf_default: f32::INFINITY,
positive_inf_default: f32::INFINITY,
infinity_default: f32::INFINITY,
positive_infinity_default: f32::INFINITY,
negative_inf_default: f32::NEG_INFINITY,
negative_infinity_default: f32::NEG_INFINITY,
double_inf_default: f64::INFINITY,
}
}
}
@@ -1906,6 +2082,14 @@ impl MonsterT {
let native_inline = native_inline_tmp.as_ref();
let long_enum_non_enum_default = self.long_enum_non_enum_default;
let long_enum_normal_default = self.long_enum_normal_default;
let nan_default = self.nan_default;
let inf_default = self.inf_default;
let positive_inf_default = self.positive_inf_default;
let infinity_default = self.infinity_default;
let positive_infinity_default = self.positive_infinity_default;
let negative_inf_default = self.negative_inf_default;
let negative_infinity_default = self.negative_infinity_default;
let double_inf_default = self.double_inf_default;
Monster::create(_fbb, &MonsterArgs{
pos,
mana,
@@ -1960,6 +2144,14 @@ impl MonsterT {
native_inline,
long_enum_non_enum_default,
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default,
})
}
}

212
tests/monster_test_suffix/ext_only/monster_test_generated.hpp
View File

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::Test native_inline{};
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
float nan_default = std::numeric_limits<float>::quiet_NaN();
float inf_default = std::numeric_limits<float>::infinity();
float positive_inf_default = std::numeric_limits<float>::infinity();
float infinity_default = std::numeric_limits<float>::infinity();
float positive_infinity_default = std::numeric_limits<float>::infinity();
float negative_inf_default = -std::numeric_limits<float>::infinity();
float negative_infinity_default = -std::numeric_limits<float>::infinity();
double double_inf_default = std::numeric_limits<double>::infinity();
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106,
VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
VT_LONG_ENUM_NORMAL_DEFAULT = 110
VT_LONG_ENUM_NORMAL_DEFAULT = 110,
VT_NAN_DEFAULT = 112,
VT_INF_DEFAULT = 114,
VT_POSITIVE_INF_DEFAULT = 116,
VT_INFINITY_DEFAULT = 118,
VT_POSITIVE_INFINITY_DEFAULT = 120,
VT_NEGATIVE_INF_DEFAULT = 122,
VT_NEGATIVE_INFINITY_DEFAULT = 124,
VT_DOUBLE_INF_DEFAULT = 126
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
}
float nan_default() const {
return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
}
bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
}
float inf_default() const {
return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
}
float positive_inf_default() const {
return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
}
float infinity_default() const {
return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
}
float positive_infinity_default() const {
return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
}
float negative_inf_default() const {
return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
}
float negative_infinity_default() const {
return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
}
double double_inf_default() const {
return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
}
bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
}
void add_nan_default(float nan_default) {
fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
}
void add_inf_default(float inf_default) {
fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
}
void add_positive_inf_default(float positive_inf_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
}
void add_infinity_default(float infinity_default) {
fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
}
void add_positive_infinity_default(float positive_infinity_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
}
void add_negative_inf_default(float negative_inf_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
}
void add_negative_infinity_default(float negative_infinity_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
}
void add_double_inf_default(double double_inf_default) {
fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
MonsterBuilder builder_(_fbb);
builder_.add_double_inf_default(double_inf_default);
builder_.add_long_enum_normal_default(long_enum_normal_default);
builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
builder_.add_negative_infinity_default(negative_infinity_default);
builder_.add_negative_inf_default(negative_inf_default);
builder_.add_positive_infinity_default(positive_infinity_default);
builder_.add_infinity_default(infinity_default);
builder_.add_positive_inf_default(positive_inf_default);
builder_.add_inf_default(inf_default);
builder_.add_nan_default(nan_default);
builder_.add_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
scalar_key_sorted_tables__,
native_inline,
long_enum_non_enum_default,
long_enum_normal_default);
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
(lhs.native_inline == rhs.native_inline) &&
(lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
(lhs.long_enum_normal_default == rhs.long_enum_normal_default);
(lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
(lhs.nan_default == rhs.nan_default) &&
(lhs.inf_default == rhs.inf_default) &&
(lhs.positive_inf_default == rhs.positive_inf_default) &&
(lhs.infinity_default == rhs.infinity_default) &&
(lhs.positive_infinity_default == rhs.positive_infinity_default) &&
(lhs.negative_inf_default == rhs.negative_inf_default) &&
(lhs.negative_infinity_default == rhs.negative_infinity_default) &&
(lhs.double_inf_default == rhs.double_inf_default);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline),
long_enum_non_enum_default(o.long_enum_non_enum_default),
long_enum_normal_default(o.long_enum_normal_default) {
long_enum_normal_default(o.long_enum_normal_default),
nan_default(o.nan_default),
inf_default(o.inf_default),
positive_inf_default(o.positive_inf_default),
infinity_default(o.infinity_default),
positive_infinity_default(o.positive_infinity_default),
negative_inf_default(o.negative_inf_default),
negative_infinity_default(o.negative_infinity_default),
double_inf_default(o.double_inf_default) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(native_inline, o.native_inline);
std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
std::swap(long_enum_normal_default, o.long_enum_normal_default);
std::swap(nan_default, o.nan_default);
std::swap(inf_default, o.inf_default);
std::swap(positive_inf_default, o.positive_inf_default);
std::swap(infinity_default, o.infinity_default);
std::swap(positive_infinity_default, o.positive_infinity_default);
std::swap(negative_inf_default, o.negative_inf_default);
std::swap(negative_infinity_default, o.negative_infinity_default);
std::swap(double_inf_default, o.double_inf_default);
return *this;
}
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
{ auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
{ auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
{ auto _e = nan_default(); _o->nan_default = _e; }
{ auto _e = inf_default(); _o->inf_default = _e; }
{ auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
{ auto _e = infinity_default(); _o->infinity_default = _e; }
{ auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
{ auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
{ auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
{ auto _e = double_inf_default(); _o->double_inf_default = _e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _native_inline = &_o->native_inline;
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
auto _long_enum_normal_default = _o->long_enum_normal_default;
auto _nan_default = _o->nan_default;
auto _inf_default = _o->inf_default;
auto _positive_inf_default = _o->positive_inf_default;
auto _infinity_default = _o->infinity_default;
auto _positive_infinity_default = _o->positive_infinity_default;
auto _negative_inf_default = _o->negative_inf_default;
auto _negative_infinity_default = _o->negative_infinity_default;
auto _double_inf_default = _o->double_inf_default;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_scalar_key_sorted_tables,
_native_inline,
_long_enum_non_enum_default,
_long_enum_normal_default);
_long_enum_normal_default,
_nan_default,
_inf_default,
_positive_inf_default,
_infinity_default,
_positive_infinity_default,
_negative_inf_default,
_negative_infinity_default,
_double_inf_default);
}
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_ULONG, 0, 12 }
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

212
tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
View File

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::Test native_inline{};
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
float nan_default = std::numeric_limits<float>::quiet_NaN();
float inf_default = std::numeric_limits<float>::infinity();
float positive_inf_default = std::numeric_limits<float>::infinity();
float infinity_default = std::numeric_limits<float>::infinity();
float positive_infinity_default = std::numeric_limits<float>::infinity();
float negative_inf_default = -std::numeric_limits<float>::infinity();
float negative_infinity_default = -std::numeric_limits<float>::infinity();
double double_inf_default = std::numeric_limits<double>::infinity();
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106,
VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
VT_LONG_ENUM_NORMAL_DEFAULT = 110
VT_LONG_ENUM_NORMAL_DEFAULT = 110,
VT_NAN_DEFAULT = 112,
VT_INF_DEFAULT = 114,
VT_POSITIVE_INF_DEFAULT = 116,
VT_INFINITY_DEFAULT = 118,
VT_POSITIVE_INFINITY_DEFAULT = 120,
VT_NEGATIVE_INF_DEFAULT = 122,
VT_NEGATIVE_INFINITY_DEFAULT = 124,
VT_DOUBLE_INF_DEFAULT = 126
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
}
float nan_default() const {
return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
}
bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
}
float inf_default() const {
return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
}
float positive_inf_default() const {
return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
}
float infinity_default() const {
return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
}
float positive_infinity_default() const {
return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
}
float negative_inf_default() const {
return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
}
float negative_infinity_default() const {
return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
}
double double_inf_default() const {
return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
}
bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
}
void add_nan_default(float nan_default) {
fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
}
void add_inf_default(float inf_default) {
fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
}
void add_positive_inf_default(float positive_inf_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
}
void add_infinity_default(float infinity_default) {
fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
}
void add_positive_infinity_default(float positive_infinity_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
}
void add_negative_inf_default(float negative_inf_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
}
void add_negative_infinity_default(float negative_infinity_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
}
void add_double_inf_default(double double_inf_default) {
fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
MonsterBuilder builder_(_fbb);
builder_.add_double_inf_default(double_inf_default);
builder_.add_long_enum_normal_default(long_enum_normal_default);
builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
builder_.add_negative_infinity_default(negative_infinity_default);
builder_.add_negative_inf_default(negative_inf_default);
builder_.add_positive_infinity_default(positive_infinity_default);
builder_.add_infinity_default(infinity_default);
builder_.add_positive_inf_default(positive_inf_default);
builder_.add_inf_default(inf_default);
builder_.add_nan_default(nan_default);
builder_.add_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
scalar_key_sorted_tables__,
native_inline,
long_enum_non_enum_default,
long_enum_normal_default);
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
(lhs.native_inline == rhs.native_inline) &&
(lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
(lhs.long_enum_normal_default == rhs.long_enum_normal_default);
(lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
(lhs.nan_default == rhs.nan_default) &&
(lhs.inf_default == rhs.inf_default) &&
(lhs.positive_inf_default == rhs.positive_inf_default) &&
(lhs.infinity_default == rhs.infinity_default) &&
(lhs.positive_infinity_default == rhs.positive_infinity_default) &&
(lhs.negative_inf_default == rhs.negative_inf_default) &&
(lhs.negative_infinity_default == rhs.negative_infinity_default) &&
(lhs.double_inf_default == rhs.double_inf_default);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline),
long_enum_non_enum_default(o.long_enum_non_enum_default),
long_enum_normal_default(o.long_enum_normal_default) {
long_enum_normal_default(o.long_enum_normal_default),
nan_default(o.nan_default),
inf_default(o.inf_default),
positive_inf_default(o.positive_inf_default),
infinity_default(o.infinity_default),
positive_infinity_default(o.positive_infinity_default),
negative_inf_default(o.negative_inf_default),
negative_infinity_default(o.negative_infinity_default),
double_inf_default(o.double_inf_default) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(native_inline, o.native_inline);
std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
std::swap(long_enum_normal_default, o.long_enum_normal_default);
std::swap(nan_default, o.nan_default);
std::swap(inf_default, o.inf_default);
std::swap(positive_inf_default, o.positive_inf_default);
std::swap(infinity_default, o.infinity_default);
std::swap(positive_infinity_default, o.positive_infinity_default);
std::swap(negative_inf_default, o.negative_inf_default);
std::swap(negative_infinity_default, o.negative_infinity_default);
std::swap(double_inf_default, o.double_inf_default);
return *this;
}
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
{ auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
{ auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
{ auto _e = nan_default(); _o->nan_default = _e; }
{ auto _e = inf_default(); _o->inf_default = _e; }
{ auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
{ auto _e = infinity_default(); _o->infinity_default = _e; }
{ auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
{ auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
{ auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
{ auto _e = double_inf_default(); _o->double_inf_default = _e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _native_inline = &_o->native_inline;
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
auto _long_enum_normal_default = _o->long_enum_normal_default;
auto _nan_default = _o->nan_default;
auto _inf_default = _o->inf_default;
auto _positive_inf_default = _o->positive_inf_default;
auto _infinity_default = _o->infinity_default;
auto _positive_infinity_default = _o->positive_infinity_default;
auto _negative_inf_default = _o->negative_inf_default;
auto _negative_infinity_default = _o->negative_infinity_default;
auto _double_inf_default = _o->double_inf_default;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_scalar_key_sorted_tables,
_native_inline,
_long_enum_non_enum_default,
_long_enum_normal_default);
_long_enum_normal_default,
_nan_default,
_inf_default,
_positive_inf_default,
_infinity_default,
_positive_infinity_default,
_negative_inf_default,
_negative_infinity_default,
_double_inf_default);
}
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_ULONG, 0, 12 }
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

212
tests/monster_test_suffix/monster_test_suffix.hpp
View File

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::Test native_inline{};
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
float nan_default = std::numeric_limits<float>::quiet_NaN();
float inf_default = std::numeric_limits<float>::infinity();
float positive_inf_default = std::numeric_limits<float>::infinity();
float infinity_default = std::numeric_limits<float>::infinity();
float positive_infinity_default = std::numeric_limits<float>::infinity();
float negative_inf_default = -std::numeric_limits<float>::infinity();
float negative_infinity_default = -std::numeric_limits<float>::infinity();
double double_inf_default = std::numeric_limits<double>::infinity();
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106,
VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
VT_LONG_ENUM_NORMAL_DEFAULT = 110
VT_LONG_ENUM_NORMAL_DEFAULT = 110,
VT_NAN_DEFAULT = 112,
VT_INF_DEFAULT = 114,
VT_POSITIVE_INF_DEFAULT = 116,
VT_INFINITY_DEFAULT = 118,
VT_POSITIVE_INFINITY_DEFAULT = 120,
VT_NEGATIVE_INF_DEFAULT = 122,
VT_NEGATIVE_INFINITY_DEFAULT = 124,
VT_DOUBLE_INF_DEFAULT = 126
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
}
float nan_default() const {
return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
}
bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
}
float inf_default() const {
return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
}
float positive_inf_default() const {
return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
}
float infinity_default() const {
return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
}
float positive_infinity_default() const {
return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
}
bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
}
float negative_inf_default() const {
return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
}
float negative_infinity_default() const {
return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
}
bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
}
double double_inf_default() const {
return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
}
bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
}
void add_nan_default(float nan_default) {
fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
}
void add_inf_default(float inf_default) {
fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
}
void add_positive_inf_default(float positive_inf_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
}
void add_infinity_default(float infinity_default) {
fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
}
void add_positive_infinity_default(float positive_infinity_default) {
fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
}
void add_negative_inf_default(float negative_inf_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
}
void add_negative_infinity_default(float negative_infinity_default) {
fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
}
void add_double_inf_default(double double_inf_default) {
fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
MonsterBuilder builder_(_fbb);
builder_.add_double_inf_default(double_inf_default);
builder_.add_long_enum_normal_default(long_enum_normal_default);
builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
builder_.add_negative_infinity_default(negative_infinity_default);
builder_.add_negative_inf_default(negative_inf_default);
builder_.add_positive_infinity_default(positive_infinity_default);
builder_.add_infinity_default(infinity_default);
builder_.add_positive_inf_default(positive_inf_default);
builder_.add_inf_default(inf_default);
builder_.add_nan_default(nan_default);
builder_.add_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = nullptr,
MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
float nan_default = std::numeric_limits<float>::quiet_NaN(),
float inf_default = std::numeric_limits<float>::infinity(),
float positive_inf_default = std::numeric_limits<float>::infinity(),
float infinity_default = std::numeric_limits<float>::infinity(),
float positive_infinity_default = std::numeric_limits<float>::infinity(),
float negative_inf_default = -std::numeric_limits<float>::infinity(),
float negative_infinity_default = -std::numeric_limits<float>::infinity(),
double double_inf_default = std::numeric_limits<double>::infinity()) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
scalar_key_sorted_tables__,
native_inline,
long_enum_non_enum_default,
long_enum_normal_default);
long_enum_normal_default,
nan_default,
inf_default,
positive_inf_default,
infinity_default,
positive_infinity_default,
negative_inf_default,
negative_infinity_default,
double_inf_default);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
(lhs.native_inline == rhs.native_inline) &&
(lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
(lhs.long_enum_normal_default == rhs.long_enum_normal_default);
(lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
(lhs.nan_default == rhs.nan_default) &&
(lhs.inf_default == rhs.inf_default) &&
(lhs.positive_inf_default == rhs.positive_inf_default) &&
(lhs.infinity_default == rhs.infinity_default) &&
(lhs.positive_infinity_default == rhs.positive_infinity_default) &&
(lhs.negative_inf_default == rhs.negative_inf_default) &&
(lhs.negative_infinity_default == rhs.negative_infinity_default) &&
(lhs.double_inf_default == rhs.double_inf_default);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline),
long_enum_non_enum_default(o.long_enum_non_enum_default),
long_enum_normal_default(o.long_enum_normal_default) {
long_enum_normal_default(o.long_enum_normal_default),
nan_default(o.nan_default),
inf_default(o.inf_default),
positive_inf_default(o.positive_inf_default),
infinity_default(o.infinity_default),
positive_infinity_default(o.positive_infinity_default),
negative_inf_default(o.negative_inf_default),
negative_infinity_default(o.negative_infinity_default),
double_inf_default(o.double_inf_default) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(native_inline, o.native_inline);
std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
std::swap(long_enum_normal_default, o.long_enum_normal_default);
std::swap(nan_default, o.nan_default);
std::swap(inf_default, o.inf_default);
std::swap(positive_inf_default, o.positive_inf_default);
std::swap(infinity_default, o.infinity_default);
std::swap(positive_infinity_default, o.positive_infinity_default);
std::swap(negative_inf_default, o.negative_inf_default);
std::swap(negative_infinity_default, o.negative_infinity_default);
std::swap(double_inf_default, o.double_inf_default);
return *this;
}
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
{ auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
{ auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
{ auto _e = nan_default(); _o->nan_default = _e; }
{ auto _e = inf_default(); _o->inf_default = _e; }
{ auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
{ auto _e = infinity_default(); _o->infinity_default = _e; }
{ auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
{ auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
{ auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
{ auto _e = double_inf_default(); _o->double_inf_default = _e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _native_inline = &_o->native_inline;
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
auto _long_enum_normal_default = _o->long_enum_normal_default;
auto _nan_default = _o->nan_default;
auto _inf_default = _o->inf_default;
auto _positive_inf_default = _o->positive_inf_default;
auto _infinity_default = _o->infinity_default;
auto _positive_infinity_default = _o->positive_infinity_default;
auto _negative_inf_default = _o->negative_inf_default;
auto _negative_infinity_default = _o->negative_infinity_default;
auto _double_inf_default = _o->double_inf_default;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_scalar_key_sorted_tables,
_native_inline,
_long_enum_non_enum_default,
_long_enum_normal_default);
_long_enum_normal_default,
_nan_default,
_inf_default,
_positive_inf_default,
_infinity_default,
_positive_infinity_default,
_negative_inf_default,
_negative_infinity_default,
_double_inf_default);
}
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_ULONG, 0, 12 }
{ flatbuffers::ET_ULONG, 0, 12 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"scalar_key_sorted_tables",
"native_inline",
"long_enum_non_enum_default",
"long_enum_normal_default"
"long_enum_normal_default",
"nan_default",
"inf_default",
"positive_inf_default",
"infinity_default",
"positive_infinity_default",
"negative_inf_default",
"negative_infinity_default",
"double_inf_default"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

17
tests/reflection_test.cpp
View File

@@ -266,10 +266,14 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
"}, "
"{ name: \"Wilma\" } ], "
// TODO(wvo): should really print this nested buffer correctly.
"testnestedflatbuffer: [ 20, 0, 0, 0, 77, 79, 78, 83, 12, 0, 12, 0, 0, "
"0, "
"4, 0, 6, 0, 8, 0, 12, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 13, 0, 0, 0, 78, "
"101, 115, 116, 101, 100, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "
"testnestedflatbuffer: [ 124, 0, 0, 0, 77, 79, 78, 83, 0, 0, 114, 0, 16, "
"0, 0, 0, 4, 0, 6, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
"0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
"0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
"0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
"0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 114, 0, 0, 0, 0, 0, 0, 0, "
"8, 0, 0, 0, 0, 0, 192, 127, 13, 0, 0, 0, 78, 101, 115, 116, 101, 100, "
"77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "
"testarrayofstring2: [ \"jane\", \"mary\" ], "
"testarrayofsortedstruct: [ { id: 0, distance: 0 }, "
"{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "
@@ -277,7 +281,8 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
"flex: [ 210, 4, 5, 2 ], "
"test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "
"vector_of_enums: [ Blue, Green ], "
"scalar_key_sorted_tables: [ { id: \"miss\" } ] "
"scalar_key_sorted_tables: [ { id: \"miss\" } ], "
"nan_default: nan "
"}");
Test test(16, 32);
@@ -317,4 +322,4 @@ void MiniReflectFixedLengthArrayTest() {
}
} // namespace tests
} // namespace flatbuffers
} // namespace flatbuffers

24
tests/rust_usage_test/tests/integration_test.rs
View File

@@ -152,8 +152,10 @@ fn object_api_defaults() {
b: 0
}
});
let mut default_without_nan = MonsterT::default();
default_without_nan.nan_default = 0.0;
assert_eq!(
MonsterT::default(),
default_without_nan,
MonsterT {
pos: None,
hp: 100,
@@ -205,6 +207,14 @@ fn object_api_defaults() {
native_inline: None,
long_enum_non_enum_default: Default::default(),
long_enum_normal_default: LongEnum::LongOne,
nan_default: 0.0,
inf_default: f32::INFINITY,
positive_inf_default: f32::INFINITY,
infinity_default: f32::INFINITY,
positive_infinity_default: f32::INFINITY,
negative_inf_default: f32::NEG_INFINITY,
negative_infinity_default: f32::NEG_INFINITY,
double_inf_default: f64::INFINITY,
}
);
}
@@ -467,7 +477,7 @@ fn verifier_apparent_size_too_large() {
});
b.finish(m, None);
let data = b.finished_data();
assert!(data.len() < 5100); // est 4000 for the vector + 1000 for the string + 100 overhead.
assert!(data.len() < 5200); // est 4000 for the vector + 1000 for the string + 200 overhead.
let mut opts = flatbuffers::VerifierOptions::default();
opts.max_apparent_size = 1_000_000;
@@ -1774,7 +1784,10 @@ mod write_and_read_examples {
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
native_inline: None, long_enum_non_enum_default: (empty), \
long_enum_normal_default: LongOne }, \
long_enum_normal_default: LongOne, nan_default: NaN, inf_default: \
inf, positive_inf_default: inf, infinity_default: inf, \
positive_infinity_default: inf, negative_inf_default: -inf, \
negative_infinity_default: -inf, double_inf_default: inf }, \
test4: Some([Test { a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
testarrayofstring: Some([\"test1\", \"test2\"]), \
testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
@@ -1794,7 +1807,10 @@ mod write_and_read_examples {
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
native_inline: None, long_enum_non_enum_default: (empty), \
long_enum_normal_default: LongOne }"
long_enum_normal_default: LongOne, nan_default: NaN, inf_default: \
inf, positive_inf_default: inf, infinity_default: inf, \
positive_infinity_default: inf, negative_inf_default: -inf, \
negative_infinity_default: -inf, double_inf_default: inf }"
);
}

124
tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
View File

@@ -1184,6 +1184,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
case nativeInline = 106
case longEnumNonEnumDefault = 108
case longEnumNormalDefault = 110
case nanDefault = 112
case infDefault = 114
case positiveInfDefault = 116
case infinityDefault = 118
case positiveInfinityDefault = 120
case negativeInfDefault = 122
case negativeInfinityDefault = 124
case doubleInfDefault = 126
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
@@ -1334,7 +1342,23 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
@discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v); return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
@discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 54) }
public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? nan : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v); return _accessor.mutate(nanDefault, index: o) }
public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v); return _accessor.mutate(infDefault, index: o) }
public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +inf : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return _accessor.mutate(positiveInfDefault, index: o) }
public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? infinity : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v); return _accessor.mutate(infinityDefault, index: o) }
public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +infinity : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return _accessor.mutate(positiveInfinityDefault, index: o) }
public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -inf : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return _accessor.mutate(negativeInfDefault, index: o) }
public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -infinity : _accessor.readBuffer(of: Float32.self, at: o) }
@discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return _accessor.mutate(negativeInfinityDefault, index: o) }
public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Double.self, at: o) }
@discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return _accessor.mutate(doubleInfDefault, index: o) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
@@ -1398,6 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: nan, at: VTOFFSET.nanDefault.p) }
public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: inf, at: VTOFFSET.infDefault.p) }
public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +inf, at: VTOFFSET.positiveInfDefault.p) }
public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: infinity, at: VTOFFSET.infinityDefault.p) }
public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +infinity, at: VTOFFSET.positiveInfinityDefault.p) }
public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -inf, at: VTOFFSET.negativeInfDefault.p) }
public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -infinity, at: VTOFFSET.negativeInfinityDefault.p) }
public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: inf, at: VTOFFSET.doubleInfDefault.p) }
public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
public static func createMonster(
_ fbb: inout FlatBufferBuilder,
@@ -1453,7 +1485,15 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
nativeInline: MyGame_Example_Test? = nil,
longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
longEnumNormalDefault: MyGame_Example_LongEnum = .longone
longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
nanDefault: Float32 = nan,
infDefault: Float32 = inf,
positiveInfDefault: Float32 = +inf,
infinityDefault: Float32 = infinity,
positiveInfinityDefault: Float32 = +infinity,
negativeInfDefault: Float32 = -inf,
negativeInfinityDefault: Float32 = -infinity,
doubleInfDefault: Double = inf
) -> Offset {
let __start = MyGame_Example_Monster.startMonster(&fbb)
MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1509,6 +1549,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb)
MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb)
MyGame_Example_Monster.add(nanDefault: nanDefault, &fbb)
MyGame_Example_Monster.add(infDefault: infDefault, &fbb)
MyGame_Example_Monster.add(positiveInfDefault: positiveInfDefault, &fbb)
MyGame_Example_Monster.add(infinityDefault: infinityDefault, &fbb)
MyGame_Example_Monster.add(positiveInfinityDefault: positiveInfinityDefault, &fbb)
MyGame_Example_Monster.add(negativeInfDefault: negativeInfDefault, &fbb)
MyGame_Example_Monster.add(negativeInfinityDefault: negativeInfinityDefault, &fbb)
MyGame_Example_Monster.add(doubleInfDefault: doubleInfDefault, &fbb)
return MyGame_Example_Monster.endMonster(&fbb, start: __start)
}
public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
@@ -1668,6 +1716,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder)
MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder)
MyGame_Example_Monster.add(nanDefault: obj.nanDefault, &builder)
MyGame_Example_Monster.add(infDefault: obj.infDefault, &builder)
MyGame_Example_Monster.add(positiveInfDefault: obj.positiveInfDefault, &builder)
MyGame_Example_Monster.add(infinityDefault: obj.infinityDefault, &builder)
MyGame_Example_Monster.add(positiveInfinityDefault: obj.positiveInfinityDefault, &builder)
MyGame_Example_Monster.add(negativeInfDefault: obj.negativeInfDefault, &builder)
MyGame_Example_Monster.add(negativeInfinityDefault: obj.negativeInfinityDefault, &builder)
MyGame_Example_Monster.add(doubleInfDefault: obj.doubleInfDefault, &builder)
return MyGame_Example_Monster.endMonster(&builder, start: __root)
}
@@ -1756,6 +1812,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
try _v.visit(field: VTOFFSET.longEnumNonEnumDefault.p, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self)
try _v.visit(field: VTOFFSET.longEnumNormalDefault.p, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self)
try _v.visit(field: VTOFFSET.nanDefault.p, fieldName: "nanDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.infDefault.p, fieldName: "infDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.positiveInfDefault.p, fieldName: "positiveInfDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.infinityDefault.p, fieldName: "infinityDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.positiveInfinityDefault.p, fieldName: "positiveInfinityDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.negativeInfDefault.p, fieldName: "negativeInfDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.negativeInfinityDefault.p, fieldName: "negativeInfinityDefault", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.doubleInfDefault.p, fieldName: "doubleInfDefault", required: false, type: Double.self)
_v.finish()
}
}
@@ -1816,6 +1880,14 @@ extension MyGame_Example_Monster: Encodable {
case nativeInline = "native_inline"
case longEnumNonEnumDefault = "long_enum_non_enum_default"
case longEnumNormalDefault = "long_enum_normal_default"
case nanDefault = "nan_default"
case infDefault = "inf_default"
case positiveInfDefault = "positive_inf_default"
case infinityDefault = "infinity_default"
case positiveInfinityDefault = "positive_infinity_default"
case negativeInfDefault = "negative_inf_default"
case negativeInfinityDefault = "negative_infinity_default"
case doubleInfDefault = "double_inf_default"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
@@ -2033,6 +2105,30 @@ extension MyGame_Example_Monster: Encodable {
if longEnumNormalDefault != .longone {
try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
}
if nanDefault != nan {
try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
}
if infDefault != inf {
try container.encodeIfPresent(infDefault, forKey: .infDefault)
}
if positiveInfDefault != +inf {
try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
}
if infinityDefault != infinity {
try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
}
if positiveInfinityDefault != +infinity {
try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
}
if negativeInfDefault != -inf {
try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
}
if negativeInfinityDefault != -infinity {
try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
}
if doubleInfDefault != inf {
try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
}
}
}
@@ -2088,6 +2184,14 @@ public class MyGame_Example_MonsterT: NativeObject {
public var nativeInline: MyGame_Example_Test?
public var longEnumNonEnumDefault: MyGame_Example_LongEnum
public var longEnumNormalDefault: MyGame_Example_LongEnum
public var nanDefault: Float32
public var infDefault: Float32
public var positiveInfDefault: Float32
public var infinityDefault: Float32
public var positiveInfinityDefault: Float32
public var negativeInfDefault: Float32
public var negativeInfinityDefault: Float32
public var doubleInfDefault: Double
public init(_ _t: inout MyGame_Example_Monster) {
pos = _t.pos
@@ -2240,6 +2344,14 @@ public class MyGame_Example_MonsterT: NativeObject {
nativeInline = _t.nativeInline
longEnumNonEnumDefault = _t.longEnumNonEnumDefault
longEnumNormalDefault = _t.longEnumNormalDefault
nanDefault = _t.nanDefault
infDefault = _t.infDefault
positiveInfDefault = _t.positiveInfDefault
infinityDefault = _t.infinityDefault
positiveInfinityDefault = _t.positiveInfinityDefault
negativeInfDefault = _t.negativeInfDefault
negativeInfinityDefault = _t.negativeInfinityDefault
doubleInfDefault = _t.doubleInfDefault
}
public init() {
@@ -2290,6 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject {
nativeInline = MyGame_Example_Test()
longEnumNonEnumDefault = .longone
longEnumNormalDefault = .longone
nanDefault = nan
infDefault = inf
positiveInfDefault = +inf
infinityDefault = infinity
positiveInfinityDefault = +infinity
negativeInfDefault = -inf
negativeInfinityDefault = -infinity
doubleInfDefault = inf
}
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

15
tests/test.cpp
View File

@@ -424,6 +424,12 @@ void UninitializedVectorTest() {
void EqualOperatorTest() {
MonsterT a;
MonsterT b;
// We have to reset the fields that are NaN to zero to allow the equality
// to evaluate to true.
TEST_EQ(std::isnan(a.nan_default), true);
TEST_EQ(std::isnan(b.nan_default), true);
a.nan_default = 0;
b.nan_default = 0;
TEST_EQ(b == a, true);
TEST_EQ(b != a, false);
@@ -442,12 +448,14 @@ void EqualOperatorTest() {
TEST_EQ(b != a, false);
a.enemy.reset(new MonsterT());
a.enemy->nan_default = 0;
TEST_EQ(b != a, true);
a.enemy->mana = 33;
TEST_EQ(b == a, false);
TEST_EQ(b != a, true);
b.enemy.reset(new MonsterT());
b.enemy->nan_default = 0;
TEST_EQ(b == a, false);
TEST_EQ(b != a, true);
b.enemy->mana = 33;
@@ -461,6 +469,7 @@ void EqualOperatorTest() {
TEST_EQ(b == a, false);
TEST_EQ(b != a, true);
a.enemy.reset(new MonsterT());
a.enemy->nan_default = 0;
TEST_EQ(b == a, true);
TEST_EQ(b != a, false);
@@ -474,23 +483,29 @@ void EqualOperatorTest() {
{
// Two tables are equal by default.
MonsterT a, b;
a.nan_default = 0;
b.nan_default = 0;
TEST_EQ(a == b, true);
// Adding only a table to one of the monster vectors should make it not
// equal (due to size mistmatch).
a.testarrayoftables.push_back(
flatbuffers::unique_ptr<MonsterT>(new MonsterT));
a.testarrayoftables.back()->nan_default = 0;
TEST_EQ(a == b, false);
// Adding an equalivant table to the other monster vector should make it
// equal again.
b.testarrayoftables.push_back(
flatbuffers::unique_ptr<MonsterT>(new MonsterT));
b.testarrayoftables.back()->nan_default = 0;
TEST_EQ(a == b, true);
// Create two new monsters that are different.
auto c = flatbuffers::unique_ptr<MonsterT>(new MonsterT);
auto d = flatbuffers::unique_ptr<MonsterT>(new MonsterT);
c->nan_default = 0;
d->nan_default = 0;
c->hp = 1;
d->hp = 2;
TEST_EQ(c == d, false);

BIN
tests/ts/monsterdata_javascript_wire.mon
View File

Binary file not shown.

132
tests/ts/my-game/example/monster.js
View File

@@ -526,11 +526,95 @@ export class Monster {
this.bb.writeUint64(this.bb_pos + offset, value);
return true;
}
nanDefault() {
const offset = this.bb.__offset(this.bb_pos, 112);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : NaN;
}
mutate_nan_default(value) {
const offset = this.bb.__offset(this.bb_pos, 112);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
infDefault() {
const offset = this.bb.__offset(this.bb_pos, 114);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_inf_default(value) {
const offset = this.bb.__offset(this.bb_pos, 114);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
positiveInfDefault() {
const offset = this.bb.__offset(this.bb_pos, 116);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_positive_inf_default(value) {
const offset = this.bb.__offset(this.bb_pos, 116);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
infinityDefault() {
const offset = this.bb.__offset(this.bb_pos, 118);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_infinity_default(value) {
const offset = this.bb.__offset(this.bb_pos, 118);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
positiveInfinityDefault() {
const offset = this.bb.__offset(this.bb_pos, 120);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_positive_infinity_default(value) {
const offset = this.bb.__offset(this.bb_pos, 120);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
negativeInfDefault() {
const offset = this.bb.__offset(this.bb_pos, 122);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : -Infinity;
}
mutate_negative_inf_default(value) {
const offset = this.bb.__offset(this.bb_pos, 122);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
negativeInfinityDefault() {
const offset = this.bb.__offset(this.bb_pos, 124);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : -Infinity;
}
mutate_negative_infinity_default(value) {
const offset = this.bb.__offset(this.bb_pos, 124);
if (offset === 0) {
return false;
}
this.bb.writeFloat32(this.bb_pos + offset, value);
return true;
}
static getFullyQualifiedName() {
return 'MyGame_Example_Monster';
}
static startMonster(builder) {
builder.startObject(54);
builder.startObject(61);
}
static addPos(builder, posOffset) {
builder.addFieldStruct(0, posOffset, 0);
@@ -870,6 +954,27 @@ export class Monster {
static addLongEnumNormalDefault(builder, longEnumNormalDefault) {
builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
}
static addNanDefault(builder, nanDefault) {
builder.addFieldFloat32(54, nanDefault, NaN);
}
static addInfDefault(builder, infDefault) {
builder.addFieldFloat32(55, infDefault, Infinity);
}
static addPositiveInfDefault(builder, positiveInfDefault) {
builder.addFieldFloat32(56, positiveInfDefault, Infinity);
}
static addInfinityDefault(builder, infinityDefault) {
builder.addFieldFloat32(57, infinityDefault, Infinity);
}
static addPositiveInfinityDefault(builder, positiveInfinityDefault) {
builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
}
static addNegativeInfDefault(builder, negativeInfDefault) {
builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
}
static addNegativeInfinityDefault(builder, negativeInfinityDefault) {
builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
}
static endMonster(builder) {
const offset = builder.endObject();
builder.requiredField(offset, 10); // name
@@ -906,7 +1011,7 @@ export class Monster {
return null;
}
return temp.unpack();
})(), this.bb.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()), this.signedEnum(), this.bb.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength()), this.bb.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()), (this.nativeInline() !== null ? this.nativeInline().unpack() : null), this.longEnumNonEnumDefault(), this.longEnumNormalDefault());
})(), this.bb.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()), this.signedEnum(), this.bb.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength()), this.bb.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()), (this.nativeInline() !== null ? this.nativeInline().unpack() : null), this.longEnumNonEnumDefault(), this.longEnumNormalDefault(), this.nanDefault(), this.infDefault(), this.positiveInfDefault(), this.infinityDefault(), this.positiveInfinityDefault(), this.negativeInfDefault(), this.negativeInfinityDefault());
}
unpackTo(_o) {
_o.pos = (this.pos() !== null ? this.pos().unpack() : null);
@@ -980,10 +1085,17 @@ export class Monster {
_o.nativeInline = (this.nativeInline() !== null ? this.nativeInline().unpack() : null);
_o.longEnumNonEnumDefault = this.longEnumNonEnumDefault();
_o.longEnumNormalDefault = this.longEnumNormalDefault();
_o.nanDefault = this.nanDefault();
_o.infDefault = this.infDefault();
_o.positiveInfDefault = this.positiveInfDefault();
_o.infinityDefault = this.infinityDefault();
_o.positiveInfinityDefault = this.positiveInfinityDefault();
_o.negativeInfDefault = this.negativeInfDefault();
_o.negativeInfinityDefault = this.negativeInfinityDefault();
}
}
export class MonsterT {
constructor(pos = null, mana = 150, hp = 100, name = null, inventory = [], color = Color.Blue, testType = Any.NONE, test = null, test4 = [], testarrayofstring = [], testarrayoftables = [], enemy = null, testnestedflatbuffer = [], testempty = null, testbool = false, testhashs32Fnv1 = 0, testhashu32Fnv1 = 0, testhashs64Fnv1 = BigInt('0'), testhashu64Fnv1 = BigInt('0'), testhashs32Fnv1a = 0, testhashu32Fnv1a = 0, testhashs64Fnv1a = BigInt('0'), testhashu64Fnv1a = BigInt('0'), testarrayofbools = [], testf = 3.14159, testf2 = 3.0, testf3 = 0.0, testarrayofstring2 = [], testarrayofsortedstruct = [], flex = [], test5 = [], vectorOfLongs = [], vectorOfDoubles = [], parentNamespaceTest = null, vectorOfReferrables = [], singleWeakReference = BigInt('0'), vectorOfWeakReferences = [], vectorOfStrongReferrables = [], coOwningReference = BigInt('0'), vectorOfCoOwningReferences = [], nonOwningReference = BigInt('0'), vectorOfNonOwningReferences = [], anyUniqueType = AnyUniqueAliases.NONE, anyUnique = null, anyAmbiguousType = AnyAmbiguousAliases.NONE, anyAmbiguous = null, vectorOfEnums = [], signedEnum = Race.None, testrequirednestedflatbuffer = [], scalarKeySortedTables = [], nativeInline = null, longEnumNonEnumDefault = BigInt('0'), longEnumNormalDefault = BigInt('2')) {
constructor(pos = null, mana = 150, hp = 100, name = null, inventory = [], color = Color.Blue, testType = Any.NONE, test = null, test4 = [], testarrayofstring = [], testarrayoftables = [], enemy = null, testnestedflatbuffer = [], testempty = null, testbool = false, testhashs32Fnv1 = 0, testhashu32Fnv1 = 0, testhashs64Fnv1 = BigInt('0'), testhashu64Fnv1 = BigInt('0'), testhashs32Fnv1a = 0, testhashu32Fnv1a = 0, testhashs64Fnv1a = BigInt('0'), testhashu64Fnv1a = BigInt('0'), testarrayofbools = [], testf = 3.14159, testf2 = 3.0, testf3 = 0.0, testarrayofstring2 = [], testarrayofsortedstruct = [], flex = [], test5 = [], vectorOfLongs = [], vectorOfDoubles = [], parentNamespaceTest = null, vectorOfReferrables = [], singleWeakReference = BigInt('0'), vectorOfWeakReferences = [], vectorOfStrongReferrables = [], coOwningReference = BigInt('0'), vectorOfCoOwningReferences = [], nonOwningReference = BigInt('0'), vectorOfNonOwningReferences = [], anyUniqueType = AnyUniqueAliases.NONE, anyUnique = null, anyAmbiguousType = AnyAmbiguousAliases.NONE, anyAmbiguous = null, vectorOfEnums = [], signedEnum = Race.None, testrequirednestedflatbuffer = [], scalarKeySortedTables = [], nativeInline = null, longEnumNonEnumDefault = BigInt('0'), longEnumNormalDefault = BigInt('2'), nanDefault = NaN, infDefault = Infinity, positiveInfDefault = Infinity, infinityDefault = Infinity, positiveInfinityDefault = Infinity, negativeInfDefault = -Infinity, negativeInfinityDefault = -Infinity) {
this.pos = pos;
this.mana = mana;
this.hp = hp;
@@ -1037,6 +1149,13 @@ export class MonsterT {
this.nativeInline = nativeInline;
this.longEnumNonEnumDefault = longEnumNonEnumDefault;
this.longEnumNormalDefault = longEnumNormalDefault;
this.nanDefault = nanDefault;
this.infDefault = infDefault;
this.positiveInfDefault = positiveInfDefault;
this.infinityDefault = infinityDefault;
this.positiveInfinityDefault = positiveInfinityDefault;
this.negativeInfDefault = negativeInfDefault;
this.negativeInfinityDefault = negativeInfinityDefault;
}
pack(builder) {
const name = (this.name !== null ? builder.createString(this.name) : 0);
@@ -1120,6 +1239,13 @@ export class MonsterT {
Monster.addNativeInline(builder, (this.nativeInline !== null ? this.nativeInline.pack(builder) : 0));
Monster.addLongEnumNonEnumDefault(builder, this.longEnumNonEnumDefault);
Monster.addLongEnumNormalDefault(builder, this.longEnumNormalDefault);
Monster.addNanDefault(builder, this.nanDefault);
Monster.addInfDefault(builder, this.infDefault);
Monster.addPositiveInfDefault(builder, this.positiveInfDefault);
Monster.addInfinityDefault(builder, this.infinityDefault);
Monster.addPositiveInfinityDefault(builder, this.positiveInfinityDefault);
Monster.addNegativeInfDefault(builder, this.negativeInfDefault);
Monster.addNegativeInfinityDefault(builder, this.negativeInfinityDefault);
return Monster.endMonster(builder);
}
}

198
tests/ts/my-game/example/monster.ts
View File

@@ -683,12 +683,140 @@ mutate_long_enum_normal_default(value:bigint):boolean {
return true;
}
nanDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 112);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : NaN;
}
mutate_nan_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 112);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
infDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 114);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_inf_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 114);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
positiveInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 116);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_positive_inf_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 116);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
infinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 118);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_infinity_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 118);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
positiveInfinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 120);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
mutate_positive_infinity_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 120);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
negativeInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 122);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
}
mutate_negative_inf_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 122);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
negativeInfinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 124);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
}
mutate_negative_infinity_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 124);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
doubleInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 126);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : Infinity;
}
mutate_double_inf_default(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 126);
if (offset === 0) {
return false;
}
this.bb!.writeFloat64(this.bb_pos + offset, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame_Example_Monster';
}
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(54);
builder.startObject(62);
}
static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) {
@@ -1124,6 +1252,38 @@ static addLongEnumNormalDefault(builder:flatbuffers.Builder, longEnumNormalDefau
builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
}
static addNanDefault(builder:flatbuffers.Builder, nanDefault:number) {
builder.addFieldFloat32(54, nanDefault, NaN);
}
static addInfDefault(builder:flatbuffers.Builder, infDefault:number) {
builder.addFieldFloat32(55, infDefault, Infinity);
}
static addPositiveInfDefault(builder:flatbuffers.Builder, positiveInfDefault:number) {
builder.addFieldFloat32(56, positiveInfDefault, Infinity);
}
static addInfinityDefault(builder:flatbuffers.Builder, infinityDefault:number) {
builder.addFieldFloat32(57, infinityDefault, Infinity);
}
static addPositiveInfinityDefault(builder:flatbuffers.Builder, positiveInfinityDefault:number) {
builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
}
static addNegativeInfDefault(builder:flatbuffers.Builder, negativeInfDefault:number) {
builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
}
static addNegativeInfinityDefault(builder:flatbuffers.Builder, negativeInfinityDefault:number) {
builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
}
static addDoubleInfDefault(builder:flatbuffers.Builder, doubleInfDefault:number) {
builder.addFieldFloat64(61, doubleInfDefault, Infinity);
}
static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
builder.requiredField(offset, 10) // name
@@ -1213,7 +1373,15 @@ unpack(): MonsterT {
this.bb!.createObjList<Stat, StatT>(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()),
(this.nativeInline() !== null ? this.nativeInline()!.unpack() : null),
this.longEnumNonEnumDefault(),
this.longEnumNormalDefault()
this.longEnumNormalDefault(),
this.nanDefault(),
this.infDefault(),
this.positiveInfDefault(),
this.infinityDefault(),
this.positiveInfinityDefault(),
this.negativeInfDefault(),
this.negativeInfinityDefault(),
this.doubleInfDefault()
);
}
@@ -1284,6 +1452,14 @@ unpackTo(_o: MonsterT): void {
_o.nativeInline = (this.nativeInline() !== null ? this.nativeInline()!.unpack() : null);
_o.longEnumNonEnumDefault = this.longEnumNonEnumDefault();
_o.longEnumNormalDefault = this.longEnumNormalDefault();
_o.nanDefault = this.nanDefault();
_o.infDefault = this.infDefault();
_o.positiveInfDefault = this.positiveInfDefault();
_o.infinityDefault = this.infinityDefault();
_o.positiveInfinityDefault = this.positiveInfinityDefault();
_o.negativeInfDefault = this.negativeInfDefault();
_o.negativeInfinityDefault = this.negativeInfinityDefault();
_o.doubleInfDefault = this.doubleInfDefault();
}
}
@@ -1341,7 +1517,15 @@ constructor(
public scalarKeySortedTables: (StatT)[] = [],
public nativeInline: TestT|null = null,
public longEnumNonEnumDefault: bigint = BigInt('0'),
public longEnumNormalDefault: bigint = BigInt('2')
public longEnumNormalDefault: bigint = BigInt('2'),
public nanDefault: number = NaN,
public infDefault: number = Infinity,
public positiveInfDefault: number = Infinity,
public infinityDefault: number = Infinity,
public positiveInfinityDefault: number = Infinity,
public negativeInfDefault: number = -Infinity,
public negativeInfinityDefault: number = -Infinity,
public doubleInfDefault: number = Infinity
){}
@@ -1428,6 +1612,14 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
Monster.addNativeInline(builder, (this.nativeInline !== null ? this.nativeInline!.pack(builder) : 0));
Monster.addLongEnumNonEnumDefault(builder, this.longEnumNonEnumDefault);
Monster.addLongEnumNormalDefault(builder, this.longEnumNormalDefault);
Monster.addNanDefault(builder, this.nanDefault);
Monster.addInfDefault(builder, this.infDefault);
Monster.addPositiveInfDefault(builder, this.positiveInfDefault);
Monster.addInfinityDefault(builder, this.infinityDefault);
Monster.addPositiveInfinityDefault(builder, this.positiveInfinityDefault);
Monster.addNegativeInfDefault(builder, this.negativeInfDefault);
Monster.addNegativeInfinityDefault(builder, this.negativeInfinityDefault);
Monster.addDoubleInfDefault(builder, this.doubleInfDefault);
return Monster.endMonster(builder);
}

74
tests/ts/ts-flat-files/monster_test_generated.ts
View File

@@ -1152,8 +1152,48 @@ longEnumNormalDefault():bigint {
return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('2');
}
nanDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 112);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : NaN;
}
infDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 114);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
positiveInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 116);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
infinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 118);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
positiveInfinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 120);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
}
negativeInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 122);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
}
negativeInfinityDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 124);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
}
doubleInfDefault():number {
const offset = this.bb!.__offset(this.bb_pos, 126);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : Infinity;
}
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(54);
builder.startObject(62);
}
static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) {
@@ -1589,6 +1629,38 @@ static addLongEnumNormalDefault(builder:flatbuffers.Builder, longEnumNormalDefau
builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
}
static addNanDefault(builder:flatbuffers.Builder, nanDefault:number) {
builder.addFieldFloat32(54, nanDefault, NaN);
}
static addInfDefault(builder:flatbuffers.Builder, infDefault:number) {
builder.addFieldFloat32(55, infDefault, Infinity);
}
static addPositiveInfDefault(builder:flatbuffers.Builder, positiveInfDefault:number) {
builder.addFieldFloat32(56, positiveInfDefault, Infinity);
}
static addInfinityDefault(builder:flatbuffers.Builder, infinityDefault:number) {
builder.addFieldFloat32(57, infinityDefault, Infinity);
}
static addPositiveInfinityDefault(builder:flatbuffers.Builder, positiveInfinityDefault:number) {
builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
}
static addNegativeInfDefault(builder:flatbuffers.Builder, negativeInfDefault:number) {
builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
}
static addNegativeInfinityDefault(builder:flatbuffers.Builder, negativeInfinityDefault:number) {
builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
}
static addDoubleInfDefault(builder:flatbuffers.Builder, doubleInfDefault:number) {
builder.addFieldFloat64(61, doubleInfDefault, Infinity);
}
static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
builder.requiredField(offset, 10) // name