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

[C++, JSON] Fix nullptr access when reading a key with a default value. (#6375)

Browse Source 
This commit fixes handling of default and NULL `key` fields in `Parser::ParseVector` (#5928).

The JSON generator updated. It outputs `key` fields even if the `--force-defaults` option is inactive.

Additional test cases for `key` added.
This commit is contained in:
Vladimir Glavnyy
2021-01-08 02:24:59 +07:00
committed by GitHub
parent 4363c1d2cb
commit 83ce29cc22
28 changed files with 1243 additions and 579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/idl_gen_text.cpp
View File

@@ -292,7 +292,7 @@ struct JsonPrinter {
it != struct_def.fields.vec.end(); ++it) {
FieldDef &fd = **it;
auto is_present = struct_def.fixed || table->CheckField(fd.value.offset);
auto output_anyway = opts.output_default_scalars_in_json &&
auto output_anyway = (opts.output_default_scalars_in_json || fd.key) &&
IsScalar(fd.value.type.base_type) && !fd.deprecated;
if (is_present || output_anyway) {
if (fieldout++) { AddComma(); }

123
src/idl_parser.cpp
View File

@@ -1351,22 +1351,71 @@ CheckedError Parser::ParseVectorDelimiters(uoffset_t &count, F body) {
return NoError();
}
static bool CompareType(const uint8_t *a, const uint8_t *b, BaseType ftype) {
switch (ftype) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
case BASE_TYPE_##ENUM: return ReadScalar<CTYPE>(a) < ReadScalar<CTYPE>(b);
static bool CompareSerializedScalars(const uint8_t *a, const uint8_t *b,
const FieldDef &key) {
switch (key.value.type.base_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
case BASE_TYPE_##ENUM: { \
CTYPE def = static_cast<CTYPE>(0); \
if (!a || !b) { StringToNumber(key.value.constant.c_str(), &def); } \
const auto av = a ? ReadScalar<CTYPE>(a) : def; \
const auto bv = b ? ReadScalar<CTYPE>(b) : def; \
return av < bv; \
}
FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
case BASE_TYPE_STRING:
// Indirect offset pointer to string pointer.
a += ReadScalar<uoffset_t>(a);
b += ReadScalar<uoffset_t>(b);
return *reinterpret_cast<const String *>(a) <
*reinterpret_cast<const String *>(b);
default: return false;
default: {
FLATBUFFERS_ASSERT(false && "scalar type expected");
return false;
}
}
}
static bool CompareTablesByScalarKey(const Offset<Table> *_a,
const Offset<Table> *_b,
const FieldDef &key) {
const voffset_t offset = key.value.offset;
// Indirect offset pointer to table pointer.
auto a = reinterpret_cast<const uint8_t *>(_a) + ReadScalar<uoffset_t>(_a);
auto b = reinterpret_cast<const uint8_t *>(_b) + ReadScalar<uoffset_t>(_b);
// Fetch field address from table.
a = reinterpret_cast<const Table *>(a)->GetAddressOf(offset);
b = reinterpret_cast<const Table *>(b)->GetAddressOf(offset);
return CompareSerializedScalars(a, b, key);
}
static bool CompareTablesByStringKey(const Offset<Table> *_a,
const Offset<Table> *_b,
const FieldDef &key) {
const voffset_t offset = key.value.offset;
// Indirect offset pointer to table pointer.
auto a = reinterpret_cast<const uint8_t *>(_a) + ReadScalar<uoffset_t>(_a);
auto b = reinterpret_cast<const uint8_t *>(_b) + ReadScalar<uoffset_t>(_b);
// Fetch field address from table.
a = reinterpret_cast<const Table *>(a)->GetAddressOf(offset);
b = reinterpret_cast<const Table *>(b)->GetAddressOf(offset);
if (a && b) {
// Indirect offset pointer to string pointer.
a += ReadScalar<uoffset_t>(a);
b += ReadScalar<uoffset_t>(b);
return *reinterpret_cast<const String *>(a) <
*reinterpret_cast<const String *>(b);
} else {
return a ? true : false;
}
}
static void SwapSerializedTables(Offset<Table> *a, Offset<Table> *b) {
// These are serialized offsets, so are relative where they are
// stored in memory, so compute the distance between these pointers:
ptrdiff_t diff = (b - a) * sizeof(Offset<Table>);
FLATBUFFERS_ASSERT(diff >= 0); // Guaranteed by SimpleQsort.
auto udiff = static_cast<uoffset_t>(diff);
a->o = EndianScalar(ReadScalar<uoffset_t>(a) - udiff);
b->o = EndianScalar(ReadScalar<uoffset_t>(b) + udiff);
std::swap(*a, *b);
}
// See below for why we need our own sort :(
template<typename T, typename F, typename S>
void SimpleQsort(T *begin, T *end, size_t width, F comparator, S swapper) {
@@ -1451,23 +1500,21 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue,
// globals, making parsing thread-unsafe.
// So for now, we use SimpleQsort above.
// TODO: replace with something better, preferably not recursive.
voffset_t offset = key->value.offset;
BaseType ftype = key->value.type.base_type;
if (type.struct_def->fixed) {
const voffset_t offset = key->value.offset;
const size_t struct_size = type.struct_def->bytesize;
auto v =
reinterpret_cast<VectorOfAny *>(builder_.GetCurrentBufferPointer());
SimpleQsort<uint8_t>(
v->Data(), v->Data() + v->size() * type.struct_def->bytesize,
type.struct_def->bytesize,
[&](const uint8_t *a, const uint8_t *b) -> bool {
return CompareType(a + offset, b + offset, ftype);
[offset, key](const uint8_t *a, const uint8_t *b) -> bool {
return CompareSerializedScalars(a + offset, b + offset, *key);
},
[&](uint8_t *a, uint8_t *b) {
[struct_size](uint8_t *a, uint8_t *b) {
// FIXME: faster?
for (size_t i = 0; i < type.struct_def->bytesize; i++) {
std::swap(a[i], b[i]);
}
for (size_t i = 0; i < struct_size; i++) { std::swap(a[i], b[i]); }
});
} else {
auto v = reinterpret_cast<Vector<Offset<Table>> *>(
@@ -1475,29 +1522,21 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue,
// Here also can't use std::sort. We do have an iterator type for it,
// but it is non-standard as it will dereference the offsets, and thus
// can't be used to swap elements.
SimpleQsort<Offset<Table>>(
v->data(), v->data() + v->size(), 1,
[&](const Offset<Table> *_a, const Offset<Table> *_b) -> bool {
// Indirect offset pointer to table pointer.
auto a = reinterpret_cast<const uint8_t *>(_a) +
ReadScalar<uoffset_t>(_a);
auto b = reinterpret_cast<const uint8_t *>(_b) +
ReadScalar<uoffset_t>(_b);
// Fetch field address from table.
a = reinterpret_cast<const Table *>(a)->GetAddressOf(offset);
b = reinterpret_cast<const Table *>(b)->GetAddressOf(offset);
return CompareType(a, b, ftype);
},
[&](Offset<Table> *a, Offset<Table> *b) {
// These are serialized offsets, so are relative where they are
// stored in memory, so compute the distance between these pointers:
ptrdiff_t diff = (b - a) * sizeof(Offset<Table>);
FLATBUFFERS_ASSERT(diff >= 0); // Guaranteed by SimpleQsort.
auto udiff = static_cast<uoffset_t>(diff);
a->o = EndianScalar(ReadScalar<uoffset_t>(a) - udiff);
b->o = EndianScalar(ReadScalar<uoffset_t>(b) + udiff);
std::swap(*a, *b);
});
if (key->value.type.base_type == BASE_TYPE_STRING) {
SimpleQsort<Offset<Table>>(
v->data(), v->data() + v->size(), 1,
[key](const Offset<Table> *_a, const Offset<Table> *_b) -> bool {
return CompareTablesByStringKey(_a, _b, *key);
},
SwapSerializedTables);
} else {
SimpleQsort<Offset<Table>>(
v->data(), v->data() + v->size(), 1,
[key](const Offset<Table> *_a, const Offset<Table> *_b) -> bool {
return CompareTablesByScalarKey(_a, _b, *key);
},
SwapSerializedTables);
}
}
}
return NoError();

48
tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
View File

@@ -524,6 +524,30 @@ public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPI {
MyGame_Example_Stat.add(count: count, &fbb)
return MyGame_Example_Stat.endStat(&fbb, start: __start)
}
public static func sortVectorOfStat(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
var off = offsets
off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 8, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 8, fbb: fbb.buffer), fbb: fbb.buffer) < 0 }
return fbb.createVector(ofOffsets: off)
}
fileprivate static func lookupByKey(vector: Int32, key: UInt16, fbb: ByteBuffer) -> MyGame_Example_Stat? {
var span = fbb.read(def: Int32.self, position: Int(vector - 4))
var start: Int32 = 0
while span != 0 {
var middle = span / 2
let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
let comp = fbb.read(def: UInt16.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 8, fbb: fbb)))
if comp > 0 {
span = middle
} else if comp < 0 {
middle += 1
start += middle
span -= middle
} else {
return MyGame_Example_Stat(fbb, o: tableOffset)
}
}
return nil
}
public mutating func unpack() -> MyGame_Example_StatT {
@@ -720,6 +744,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
case vectorOfEnums = 98
case signedEnum = 100
case testrequirednestedflatbuffer = 102
case scalarKeySortedTables = 104
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
@@ -841,7 +866,10 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
public func testrequirednestedflatbuffer(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
public var testrequirednestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testrequirednestedflatbuffer.v) ?? [] }
public func mutate(testrequirednestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return _accessor.directMutate(testrequirednestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 50) }
public var scalarKeySortedTablesCount: Int32 { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
public func scalarKeySortedTables(at index: Int32) -> MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
public func scalarKeySortedTablesBy(key: UInt16) -> MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.scalarKeySortedTables.v); return o == 0 ? nil : MyGame_Example_Stat.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 51) }
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) }
@@ -901,6 +929,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
public static func addVectorOf(vectorOfEnums: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VTOFFSET.vectorOfEnums.p) }
public static func add(signedEnum: MyGame_Example_Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VTOFFSET.signedEnum.p) }
public static func addVectorOf(testrequirednestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VTOFFSET.testrequirednestedflatbuffer.p) }
public static func addVectorOf(scalarKeySortedTables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: scalarKeySortedTables, at: VTOFFSET.scalarKeySortedTables.p) }
public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
public static func createMonster(
_ fbb: inout FlatBufferBuilder,
@@ -952,7 +981,8 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
offsetOfAnyAmbiguous anyAmbiguous: Offset<UOffset> = Offset(),
vectorOfVectorOfEnums vectorOfEnums: Offset<UOffset> = Offset(),
signedEnum: MyGame_Example_Race = .none_,
vectorOfTestrequirednestedflatbuffer testrequirednestedflatbuffer: Offset<UOffset> = Offset()
vectorOfTestrequirednestedflatbuffer testrequirednestedflatbuffer: Offset<UOffset> = Offset(),
vectorOfScalarKeySortedTables scalarKeySortedTables: Offset<UOffset> = Offset()
) -> Offset<UOffset> {
let __start = MyGame_Example_Monster.startMonster(&fbb)
MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1004,6 +1034,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
MyGame_Example_Monster.addVectorOf(vectorOfEnums: vectorOfEnums, &fbb)
MyGame_Example_Monster.add(signedEnum: signedEnum, &fbb)
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: testrequirednestedflatbuffer, &fbb)
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: scalarKeySortedTables, &fbb)
return MyGame_Example_Monster.endMonster(&fbb, start: __start)
}
public static func sortVectorOfMonster(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
@@ -1095,6 +1126,11 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
var __scalarKeySortedTables__: [Offset<UOffset>] = []
for var i in obj.scalarKeySortedTables {
__scalarKeySortedTables__.append(MyGame_Example_Stat.pack(&builder, obj: &i))
}
let __scalarKeySortedTables = builder.createVector(ofOffsets: __scalarKeySortedTables__)
let __root = MyGame_Example_Monster.startMonster(&builder)
MyGame_Example_Monster.add(pos: obj.pos, &builder)
MyGame_Example_Monster.add(mana: obj.mana, &builder)
@@ -1154,6 +1190,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: __scalarKeySortedTables, &builder)
return MyGame_Example_Monster.endMonster(&builder, start: __root)
}
}
@@ -1206,6 +1243,7 @@ public class MyGame_Example_MonsterT: UnionObject {
public var vectorOfEnums: [MyGame_Example_Color]
public var signedEnum: MyGame_Example_Race
public var testrequirednestedflatbuffer: [UInt8]
public var scalarKeySortedTables: [MyGame_Example_StatT?]
public init(_ _t: inout MyGame_Example_Monster) {
pos = _t.pos
@@ -1350,6 +1388,11 @@ public class MyGame_Example_MonsterT: UnionObject {
for index in 0..<_t.testrequirednestedflatbufferCount {
testrequirednestedflatbuffer.append(_t.testrequirednestedflatbuffer(at: index))
}
scalarKeySortedTables = []
for index in 0..<_t.scalarKeySortedTablesCount {
var __v_ = _t.scalarKeySortedTables(at: index)
scalarKeySortedTables.append(__v_?.unpack())
}
}
public init() {
@@ -1396,6 +1439,7 @@ public class MyGame_Example_MonsterT: UnionObject {
vectorOfEnums = []
signedEnum = .none_
testrequirednestedflatbuffer = []
scalarKeySortedTables = []
}
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

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

@@ -207,6 +207,9 @@ public struct Monster : IFlatbufferObject
public byte[] GetTestrequirednestedflatbufferArray() { return __p.__vector_as_array<byte>(102); }
public MyGame.Example.Monster? GetTestrequirednestedflatbufferAsMonster() { int o = __p.__offset(102); return o != 0 ? (MyGame.Example.Monster?)(new MyGame.Example.Monster()).__assign(__p.__indirect(__p.__vector(o)), __p.bb) : null; }
public bool MutateTestrequirednestedflatbuffer(int j, byte testrequirednestedflatbuffer) { int o = __p.__offset(102); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, testrequirednestedflatbuffer); return true; } else { return false; } }
public MyGame.Example.Stat? ScalarKeySortedTables(int j) { int o = __p.__offset(104); return o != 0 ? (MyGame.Example.Stat?)(new MyGame.Example.Stat()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
public int ScalarKeySortedTablesLength { get { int o = __p.__offset(104); return o != 0 ? __p.__vector_len(o) : 0; } }
public MyGame.Example.Stat? ScalarKeySortedTablesByKey(ushort key) { int o = __p.__offset(104); return o != 0 ? MyGame.Example.Stat.__lookup_by_key(__p.__vector(o), key, __p.bb) : null; }
public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
MyGame.Example.Vec3T pos = null,
@@ -257,8 +260,9 @@ public struct Monster : IFlatbufferObject
int any_ambiguousOffset = 0,
VectorOffset vector_of_enumsOffset = default(VectorOffset),
MyGame.Example.Race signed_enum = MyGame.Example.Race.None,
VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset)) {
builder.StartTable(50);
VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset),
VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset)) {
builder.StartTable(51);
Monster.AddNonOwningReference(builder, non_owning_reference);
Monster.AddCoOwningReference(builder, co_owning_reference);
Monster.AddSingleWeakReference(builder, single_weak_reference);
@@ -266,6 +270,7 @@ public struct Monster : IFlatbufferObject
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
Monster.AddScalarKeySortedTables(builder, scalar_key_sorted_tablesOffset);
Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
Monster.AddAnyAmbiguous(builder, any_ambiguousOffset);
@@ -311,7 +316,7 @@ public struct Monster : IFlatbufferObject
return Monster.EndMonster(builder);
}
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(50); }
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(51); }
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); }
@@ -412,6 +417,10 @@ public struct Monster : IFlatbufferObject
public static VectorOffset CreateTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
public static void StartTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
public static void AddScalarKeySortedTables(FlatBufferBuilder builder, VectorOffset scalarKeySortedTablesOffset) { builder.AddOffset(50, scalarKeySortedTablesOffset.Value, 0); }
public static VectorOffset CreateScalarKeySortedTablesVector(FlatBufferBuilder builder, Offset<MyGame.Example.Stat>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
public static VectorOffset CreateScalarKeySortedTablesVectorBlock(FlatBufferBuilder builder, Offset<MyGame.Example.Stat>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
public static void StartScalarKeySortedTablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
int o = builder.EndTable();
builder.Required(o, 10); // name
@@ -555,6 +564,8 @@ public struct Monster : IFlatbufferObject
_o.SignedEnum = this.SignedEnum;
_o.Testrequirednestedflatbuffer = new List<byte>();
for (var _j = 0; _j < this.TestrequirednestedflatbufferLength; ++_j) {_o.Testrequirednestedflatbuffer.Add(this.Testrequirednestedflatbuffer(_j));}
_o.ScalarKeySortedTables = new List<MyGame.Example.StatT>();
for (var _j = 0; _j < this.ScalarKeySortedTablesLength; ++_j) {_o.ScalarKeySortedTables.Add(this.ScalarKeySortedTables(_j).HasValue ? this.ScalarKeySortedTables(_j).Value.UnPack() : null);}
}
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -671,6 +682,12 @@ public struct Monster : IFlatbufferObject
var __testrequirednestedflatbuffer = _o.Testrequirednestedflatbuffer.ToArray();
_testrequirednestedflatbuffer = CreateTestrequirednestedflatbufferVector(builder, __testrequirednestedflatbuffer);
}
var _scalar_key_sorted_tables = default(VectorOffset);
if (_o.ScalarKeySortedTables != null) {
var __scalar_key_sorted_tables = new Offset<MyGame.Example.Stat>[_o.ScalarKeySortedTables.Count];
for (var _j = 0; _j < __scalar_key_sorted_tables.Length; ++_j) { __scalar_key_sorted_tables[_j] = MyGame.Example.Stat.Pack(builder, _o.ScalarKeySortedTables[_j]); }
_scalar_key_sorted_tables = CreateScalarKeySortedTablesVector(builder, __scalar_key_sorted_tables);
}
return CreateMonster(
builder,
_o.Pos,
@@ -721,7 +738,8 @@ public struct Monster : IFlatbufferObject
_any_ambiguous,
_vector_of_enums,
_o.SignedEnum,
_testrequirednestedflatbuffer);
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
}
};
@@ -866,6 +884,8 @@ public class MonsterT
public MyGame.Example.Race SignedEnum { get; set; }
[Newtonsoft.Json.JsonProperty("testrequirednestedflatbuffer")]
public List<byte> Testrequirednestedflatbuffer { get; set; }
[Newtonsoft.Json.JsonProperty("scalar_key_sorted_tables")]
public List<MyGame.Example.StatT> ScalarKeySortedTables { get; set; }
public MonsterT() {
this.Pos = new MyGame.Example.Vec3T();
@@ -914,6 +934,7 @@ public class MonsterT
this.VectorOfEnums = null;
this.SignedEnum = MyGame.Example.Race.None;
this.Testrequirednestedflatbuffer = null;
this.ScalarKeySortedTables = null;
}
public static MonsterT DeserializeFromJson(string jsonText) {

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

@@ -56,6 +56,7 @@ type MonsterT struct {
VectorOfEnums []Color
SignedEnum Race
Testrequirednestedflatbuffer []byte
ScalarKeySortedTables []*StatT
}
func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -241,6 +242,19 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
if t.Testrequirednestedflatbuffer != nil {
testrequirednestedflatbufferOffset = builder.CreateByteString(t.Testrequirednestedflatbuffer)
}
scalarKeySortedTablesOffset := flatbuffers.UOffsetT(0)
if t.ScalarKeySortedTables != nil {
scalarKeySortedTablesLength := len(t.ScalarKeySortedTables)
scalarKeySortedTablesOffsets := make([]flatbuffers.UOffsetT, scalarKeySortedTablesLength)
for j := 0; j < scalarKeySortedTablesLength; j++ {
scalarKeySortedTablesOffsets[j] = t.ScalarKeySortedTables[j].Pack(builder)
}
MonsterStartScalarKeySortedTablesVector(builder, scalarKeySortedTablesLength)
for j := scalarKeySortedTablesLength - 1; j >= 0; j-- {
builder.PrependUOffsetT(scalarKeySortedTablesOffsets[j])
}
scalarKeySortedTablesOffset = builder.EndVector(scalarKeySortedTablesLength)
}
MonsterStart(builder)
posOffset := t.Pos.Pack(builder)
MonsterAddPos(builder, posOffset)
@@ -298,6 +312,7 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset)
MonsterAddSignedEnum(builder, t.SignedEnum)
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset)
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTablesOffset)
return MonsterEnd(builder)
}
@@ -429,6 +444,13 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
}
t.SignedEnum = rcv.SignedEnum()
t.Testrequirednestedflatbuffer = rcv.TestrequirednestedflatbufferBytes()
scalarKeySortedTablesLength := rcv.ScalarKeySortedTablesLength()
t.ScalarKeySortedTables = make([]*StatT, scalarKeySortedTablesLength)
for j := 0; j < scalarKeySortedTablesLength; j++ {
x := Stat{}
rcv.ScalarKeySortedTables(&x, j)
t.ScalarKeySortedTables[j] = x.UnPack()
}
}
func (rcv *Monster) UnPack() *MonsterT {
@@ -1297,8 +1319,28 @@ func (rcv *Monster) MutateTestrequirednestedflatbuffer(j int, n byte) bool {
return false
}
func (rcv *Monster) ScalarKeySortedTables(obj *Stat, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(104))
if o != 0 {
x := rcv._tab.Vector(o)
x += flatbuffers.UOffsetT(j) * 4
x = rcv._tab.Indirect(x)
obj.Init(rcv._tab.Bytes, x)
return true
}
return false
}
func (rcv *Monster) ScalarKeySortedTablesLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(104))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func MonsterStart(builder *flatbuffers.Builder) {
builder.StartObject(50)
builder.StartObject(51)
}
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1504,6 +1546,12 @@ func MonsterAddTestrequirednestedflatbuffer(builder *flatbuffers.Builder, testre
func MonsterStartTestrequirednestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(1, numElems, 1)
}
func MonsterAddScalarKeySortedTables(builder *flatbuffers.Builder, scalarKeySortedTables flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(50, flatbuffers.UOffsetT(scalarKeySortedTables), 0)
}
func MonsterStartScalarKeySortedTablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}

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

@@ -203,8 +203,15 @@ public final class Monster extends Table {
public MyGame.Example.Monster testrequirednestedflatbufferAsMonster() { return testrequirednestedflatbufferAsMonster(new MyGame.Example.Monster()); }
public MyGame.Example.Monster testrequirednestedflatbufferAsMonster(MyGame.Example.Monster obj) { int o = __offset(102); return o != 0 ? obj.__assign(__indirect(__vector(o)), bb) : null; }
public boolean mutateTestrequirednestedflatbuffer(int j, int testrequirednestedflatbuffer) { int o = __offset(102); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)testrequirednestedflatbuffer); return true; } else { return false; } }
public MyGame.Example.Stat scalarKeySortedTables(int j) { return scalarKeySortedTables(new MyGame.Example.Stat(), j); }
public MyGame.Example.Stat scalarKeySortedTables(MyGame.Example.Stat obj, int j) { int o = __offset(104); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
public int scalarKeySortedTablesLength() { int o = __offset(104); return o != 0 ? __vector_len(o) : 0; }
public MyGame.Example.Stat scalarKeySortedTablesByKey(int key) { int o = __offset(104); return o != 0 ? MyGame.Example.Stat.__lookup_by_key(null, __vector(o), key, bb) : null; }
public MyGame.Example.Stat scalarKeySortedTablesByKey(MyGame.Example.Stat obj, int key) { int o = __offset(104); return o != 0 ? MyGame.Example.Stat.__lookup_by_key(obj, __vector(o), key, bb) : null; }
public MyGame.Example.Stat.Vector scalarKeySortedTablesVector() { return scalarKeySortedTablesVector(new MyGame.Example.Stat.Vector()); }
public MyGame.Example.Stat.Vector scalarKeySortedTablesVector(MyGame.Example.Stat.Vector obj) { int o = __offset(104); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(50); }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(51); }
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); }
@@ -294,6 +301,9 @@ public final class Monster extends Table {
public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addScalarKeySortedTables(FlatBufferBuilder builder, int scalarKeySortedTablesOffset) { builder.addOffset(50, scalarKeySortedTablesOffset, 0); }
public static int createScalarKeySortedTablesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
public static void startScalarKeySortedTablesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
public static int endMonster(FlatBufferBuilder builder) {
int o = builder.endTable();
builder.required(o, 10); // name

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

@@ -805,6 +805,35 @@ class Monster : Table() {
false
}
}
fun scalarKeySortedTables(j: Int) : MyGame.Example.Stat? = scalarKeySortedTables(MyGame.Example.Stat(), j)
fun scalarKeySortedTables(obj: MyGame.Example.Stat, j: Int) : MyGame.Example.Stat? {
val o = __offset(104)
return if (o != 0) {
obj.__assign(__indirect(__vector(o) + j * 4), bb)
} else {
null
}
}
val scalarKeySortedTablesLength : Int
get() {
val o = __offset(104); return if (o != 0) __vector_len(o) else 0
}
fun scalarKeySortedTablesByKey(key: UShort) : MyGame.Example.Stat? {
val o = __offset(104)
return if (o != 0) {
MyGame.Example.Stat.__lookup_by_key(null, __vector(o), key, bb)
} else {
null
}
}
fun scalarKeySortedTablesByKey(obj: MyGame.Example.Stat, key: UShort) : MyGame.Example.Stat? {
val o = __offset(104)
return if (o != 0) {
MyGame.Example.Stat.__lookup_by_key(obj, __vector(o), key, bb)
} else {
null
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
@@ -816,7 +845,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(50)
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(51)
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)
@@ -997,6 +1026,15 @@ class Monster : Table() {
return builder.endVector()
}
fun startTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addScalarKeySortedTables(builder: FlatBufferBuilder, scalarKeySortedTables: Int) = builder.addOffset(50, scalarKeySortedTables, 0)
fun createScalarKeySortedTablesVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startScalarKeySortedTablesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)

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

@@ -544,7 +544,25 @@ function Monster_mt:TestrequirednestedflatbufferLength()
end
return 0
end
function Monster.Start(builder) builder:StartObject(50) end
function Monster_mt:ScalarKeySortedTables(j)
local o = self.view:Offset(104)
if o ~= 0 then
local x = self.view:Vector(o)
x = x + ((j-1) * 4)
x = self.view:Indirect(x)
local obj = require('MyGame.Example.Stat').New()
obj:Init(self.view.bytes, x)
return obj
end
end
function Monster_mt:ScalarKeySortedTablesLength()
local o = self.view:Offset(104)
if o ~= 0 then
return self.view:VectorLen(o)
end
return 0
end
function Monster.Start(builder) builder:StartObject(51) end
function Monster.AddPos(builder, pos) builder:PrependStructSlot(0, pos, 0) end
function Monster.AddMana(builder, mana) builder:PrependInt16Slot(1, mana, 150) end
function Monster.AddHp(builder, hp) builder:PrependInt16Slot(2, hp, 100) end
@@ -613,6 +631,8 @@ function Monster.StartVectorOfEnumsVector(builder, numElems) return builder:Star
function Monster.AddSignedEnum(builder, signedEnum) builder:PrependInt8Slot(48, signedEnum, -1) end
function Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) builder:PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer, 0) end
function Monster.StartTestrequirednestedflatbufferVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
function Monster.AddScalarKeySortedTables(builder, scalarKeySortedTables) builder:PrependUOffsetTRelativeSlot(50, scalarKeySortedTables, 0) end
function Monster.StartScalarKeySortedTablesVector(builder, numElems) return builder:StartVector(4, numElems, 4) end
function Monster.End(builder) return builder:EndObject() end
return Monster -- return the module

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

@@ -710,22 +710,41 @@ class Monster extends Table
return $this->__vector_as_bytes(102);
}
/**
* @returnVectorOffset
*/
public function getScalarKeySortedTables($j)
{
$o = $this->__offset(104);
$obj = new Stat();
return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
}
/**
* @return int
*/
public function getScalarKeySortedTablesLength()
{
$o = $this->__offset(104);
return $o != 0 ? $this->__vector_len($o) : 0;
}
/**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMonster(FlatBufferBuilder $builder)
{
$builder->StartObject(50);
$builder->StartObject(51);
}
/**
* @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)
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)
{
$builder->startObject(50);
$builder->startObject(51);
self::addPos($builder, $pos);
self::addMana($builder, $mana);
self::addHp($builder, $hp);
@@ -775,6 +794,7 @@ class Monster extends Table
self::addVectorOfEnums($builder, $vector_of_enums);
self::addSignedEnum($builder, $signed_enum);
self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
self::addScalarKeySortedTables($builder, $scalar_key_sorted_tables);
$o = $builder->endObject();
$builder->required($o, 10); // name
return $o;
@@ -1711,6 +1731,40 @@ class Monster extends Table
$builder->startVector(1, $numElems, 1);
}
/**
* @param FlatBufferBuilder $builder
* @param VectorOffset
* @return void
*/
public static function addScalarKeySortedTables(FlatBufferBuilder $builder, $scalarKeySortedTables)
{
$builder->addOffsetX(50, $scalarKeySortedTables, 0);
}
/**
* @param FlatBufferBuilder $builder
* @param array offset array
* @return int vector offset
*/
public static function createScalarKeySortedTablesVector(FlatBufferBuilder $builder, array $data)
{
$builder->startVector(4, count($data), 4);
for ($i = count($data) - 1; $i >= 0; $i--) {
$builder->putOffset($data[$i]);
}
return $builder->endVector();
}
/**
* @param FlatBufferBuilder $builder
* @param int $numElems
* @return void
*/
public static function startScalarKeySortedTablesVector(FlatBufferBuilder $builder, $numElems)
{
$builder->startVector(4, $numElems, 4);
}
/**
* @param FlatBufferBuilder $builder
* @return int table offset

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

@@ -762,7 +762,32 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
return o == 0
def MonsterStart(builder): builder.StartObject(50)
# Monster
def ScalarKeySortedTables(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
from MyGame.Example.Stat import Stat
obj = Stat()
obj.Init(self._tab.Bytes, x)
return obj
return None
# Monster
def ScalarKeySortedTablesLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Monster
def ScalarKeySortedTablesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
def MonsterStart(builder): builder.StartObject(51)
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)
@@ -841,6 +866,8 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterEnd(builder): return builder.EndObject()
import MyGame.Example.Ability
@@ -912,6 +939,7 @@ class MonsterT(object):
self.vectorOfEnums = None # type: List[int]
self.signedEnum = -1 # type: int
self.testrequirednestedflatbuffer = None # type: List[int]
self.scalarKeySortedTables = None # type: List[MyGame.Example.Stat.StatT]
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1096,6 +1124,14 @@ class MonsterT(object):
self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
else:
self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
if not monster.ScalarKeySortedTablesIsNone():
self.scalarKeySortedTables = []
for i in range(monster.ScalarKeySortedTablesLength()):
if monster.ScalarKeySortedTables(i) is None:
self.scalarKeySortedTables.append(None)
else:
stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
self.scalarKeySortedTables.append(stat_)
# MonsterT
def Pack(self, builder):
@@ -1256,6 +1292,14 @@ class MonsterT(object):
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector()
if self.scalarKeySortedTables is not None:
scalarKeySortedTableslist = []
for i in range(len(self.scalarKeySortedTables)):
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
for i in reversed(range(len(self.scalarKeySortedTables))):
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
scalarKeySortedTables = builder.EndVector()
MonsterStart(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
@@ -1334,5 +1378,7 @@ class MonsterT(object):
MonsterAddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None:
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = MonsterEnd(builder)
return monster

25
tests/MyGame/Example/Stat.cs
View File

@@ -50,6 +50,31 @@ public struct Stat : IFlatbufferObject
int o = builder.EndTable();
return new Offset<MyGame.Example.Stat>(o);
}
public static VectorOffset CreateSortedVectorOfStat(FlatBufferBuilder builder, Offset<Stat>[] offsets) {
Array.Sort(offsets, (Offset<Stat> o1, Offset<Stat> o2) => builder.DataBuffer.GetUshort(Table.__offset(8, o1.Value, builder.DataBuffer)).CompareTo(builder.DataBuffer.GetUshort(Table.__offset(8, o2.Value, builder.DataBuffer))));
return builder.CreateVectorOfTables(offsets);
}
public static Stat? __lookup_by_key(int vectorLocation, ushort key, ByteBuffer bb) {
int span = bb.GetInt(vectorLocation - 4);
int start = 0;
while (span != 0) {
int middle = span / 2;
int tableOffset = Table.__indirect(vectorLocation + 4 * (start + middle), bb);
int comp = bb.GetUshort(Table.__offset(8, bb.Length - tableOffset, bb)).CompareTo(key);
if (comp > 0) {
span = middle;
} else if (comp < 0) {
middle++;
start += middle;
span -= middle;
} else {
return new Stat().__assign(tableOffset, bb);
}
}
return null;
}
public StatT UnPack() {
var _o = new StatT();
this.UnPackTo(_o);

30
tests/MyGame/Example/Stat.java
View File

@@ -43,11 +43,41 @@ public final class Stat extends Table {
return o;
}
@Override
protected int keysCompare(Integer o1, Integer o2, ByteBuffer _bb) {
int val_1 = _bb.getShort(__offset(8, o1, _bb)) & 0xFFFF;
int val_2 = _bb.getShort(__offset(8, o2, _bb)) & 0xFFFF;
return val_1 > val_2 ? 1 : val_1 < val_2 ? -1 : 0;
}
public static Stat __lookup_by_key(Stat obj, int vectorLocation, int key, ByteBuffer bb) {
int span = bb.getInt(vectorLocation - 4);
int start = 0;
while (span != 0) {
int middle = span / 2;
int tableOffset = __indirect(vectorLocation + 4 * (start + middle), bb);
int val = bb.getShort(__offset(8, bb.capacity() - tableOffset, bb)) & 0xFFFF;
int comp = val > key ? 1 : val < key ? -1 : 0;
if (comp > 0) {
span = middle;
} else if (comp < 0) {
middle++;
start += middle;
span -= middle;
} else {
return (obj == null ? new Stat() : obj).__assign(tableOffset, bb);
}
}
return null;
}
public static final class Vector extends BaseVector {
public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
public Stat get(int j) { return get(new Stat(), j); }
public Stat get(Stat obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
public Stat getByKey(int key) { return __lookup_by_key(null, __vector(), key, bb); }
public Stat getByKey(Stat obj, int key) { return __lookup_by_key(obj, __vector(), key, bb); }
}
}

27
tests/MyGame/Example/Stat.kt
View File

@@ -52,6 +52,11 @@ class Stat : Table() {
false
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
val val_1 = _bb.getShort(__offset(8, o1, _bb))
val val_2 = _bb.getShort(__offset(8, o2, _bb))
return (val_1 - val_2).sign
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsStat(_bb: ByteBuffer): Stat = getRootAsStat(_bb, Stat())
@@ -74,5 +79,27 @@ class Stat : Table() {
val o = builder.endTable()
return o
}
fun __lookup_by_key(obj: Stat?, vectorLocation: Int, key: UShort, bb: ByteBuffer) : Stat? {
var span = bb.getInt(vectorLocation - 4)
var start = 0
while (span != 0) {
var middle = span / 2
val tableOffset = __indirect(vectorLocation + 4 * (start + middle), bb)
val value = bb.getShort(__offset(8, bb.capacity() - tableOffset, bb)).toUShort()
val comp = value.compareTo(key)
when {
comp > 0 -> span = middle
comp < 0 -> {
middle++
start += middle
span -= middle
}
else -> {
return (obj ?: Stat()).__assign(tableOffset, bb)
}
}
}
return null
}
}
}

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

@@ -830,6 +830,12 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_count(uint16_t _count) {
return SetField<uint16_t>(VT_COUNT, _count, 0);
}
bool KeyCompareLessThan(const Stat *o) const {
return count() < o->count();
}
int KeyCompareWithValue(uint16_t val) const {
return static_cast<int>(count() > val) - static_cast<int>(count() < val);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
@@ -1017,6 +1023,7 @@ struct MonsterT : public flatbuffers::NativeTable {
std::vector<MyGame::Example::Color> vector_of_enums{};
MyGame::Example::Race signed_enum = MyGame::Example::Race::None;
std::vector<uint8_t> testrequirednestedflatbuffer{};
std::vector<std::unique_ptr<MyGame::Example::StatT>> scalar_key_sorted_tables{};
};
/// an example documentation comment: "monster object"
@@ -1076,7 +1083,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_ANY_AMBIGUOUS = 96,
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102
VT_TESTREQUIREDNESTEDFLATBUFFER = 102,
VT_SCALAR_KEY_SORTED_TABLES = 104
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1409,6 +1417,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
}
const flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
}
flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *mutable_scalar_key_sorted_tables() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1491,6 +1505,9 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
verifier.VerifyVector(scalar_key_sorted_tables()) &&
verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1673,6 +1690,9 @@ struct MonsterBuilder {
void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
void add_scalar_key_sorted_tables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables) {
fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1735,7 +1755,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<void> any_ambiguous = 0,
flatbuffers::Offset<flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums = 0,
MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -1744,6 +1765,7 @@ 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_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
builder_.add_any_ambiguous(any_ambiguous);
@@ -1844,7 +1866,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
flatbuffers::Offset<void> any_ambiguous = 0,
const std::vector<MyGame::Example::Color> *vector_of_enums = nullptr,
MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr) {
const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr,
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr) {
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;
@@ -1865,6 +1888,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<MyGame::Example::Color>(*vector_of_enums) : 0;
auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Stat>(scalar_key_sorted_tables) : 0;
return MyGame::Example::CreateMonster(
_fbb,
pos,
@@ -1915,7 +1939,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
any_ambiguous,
vector_of_enums__,
signed_enum,
testrequirednestedflatbuffer__);
testrequirednestedflatbuffer__,
scalar_key_sorted_tables__);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2375,6 +2400,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<MyGame::Example::Color>(_e->Get(_i)); } } }
{ auto _e = signed_enum(); _o->signed_enum = _e; }
{ auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
{ auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scalar_key_sorted_tables[_i] = std::unique_ptr<MyGame::Example::StatT>(_e->Get(_i)->UnPack(_resolver)); } } }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2434,6 +2460,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
auto _signed_enum = _o->signed_enum;
auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2484,7 +2511,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_any_ambiguous,
_vector_of_enums,
_signed_enum,
_testrequirednestedflatbuffer);
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3172,7 +3200,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 0, 10 },
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 }
{ flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 5 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3238,10 +3267,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"any_ambiguous",
"vector_of_enums",
"signed_enum",
"testrequirednestedflatbuffer"
"testrequirednestedflatbuffer",
"scalar_key_sorted_tables"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 50, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 51, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

BIN
tests/monster_test.bfbs
View File

Binary file not shown.

3
tests/monster_test.fbs
View File

@@ -59,7 +59,7 @@ struct Ability {
table Stat {
id:string;
val:long;
count:ushort;
count:ushort (key);
}
table Referrable {
@@ -117,6 +117,7 @@ table Monster {
vector_of_enums:[Color] (id:47);
signed_enum:Race = None (id:48);
testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: "Monster");
scalar_key_sorted_tables:[Stat] (id: 50);
}
table TypeAliases {

3
tests/monster_test.schema.json
View File

@@ -299,6 +299,9 @@
},
"testrequirednestedflatbuffer" : {
"type" : "array", "items" : {"type" : "integer", "minimum" : 0, "maximum" :255"}
},
"scalar_key_sorted_tables" : {
"type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_Stat"}
}
},
"required" : ["name"],

990
tests/monster_test_bfbs_generated.h
View File

File diff suppressed because it is too large Load Diff

49
tests/monster_test_generated.h
View File

@@ -1003,6 +1003,12 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_count(uint16_t _count) {
return SetField<uint16_t>(VT_COUNT, _count, 0);
}
bool KeyCompareLessThan(const Stat *o) const {
return count() < o->count();
}
int KeyCompareWithValue(uint16_t val) const {
return static_cast<int>(count() > val) - static_cast<int>(count() < val);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
@@ -1189,6 +1195,7 @@ struct MonsterT : public flatbuffers::NativeTable {
std::vector<MyGame::Example::Color> vector_of_enums{};
MyGame::Example::Race signed_enum = MyGame::Example::Race_None;
std::vector<uint8_t> testrequirednestedflatbuffer{};
std::vector<flatbuffers::unique_ptr<MyGame::Example::StatT>> scalar_key_sorted_tables{};
};
inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
@@ -1238,7 +1245,8 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.any_ambiguous == rhs.any_ambiguous) &&
(lhs.vector_of_enums == rhs.vector_of_enums) &&
(lhs.signed_enum == rhs.signed_enum) &&
(lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer);
(lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer) &&
(lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -1302,7 +1310,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_ANY_AMBIGUOUS = 96,
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102
VT_TESTREQUIREDNESTEDFLATBUFFER = 102,
VT_SCALAR_KEY_SORTED_TABLES = 104
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1635,6 +1644,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
}
const flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
}
flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *mutable_scalar_key_sorted_tables() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1717,6 +1732,9 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
verifier.VerifyVector(scalar_key_sorted_tables()) &&
verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1899,6 +1917,9 @@ struct MonsterBuilder {
void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
void add_scalar_key_sorted_tables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables) {
fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1961,7 +1982,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<void> any_ambiguous = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> vector_of_enums = 0,
MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -1970,6 +1992,7 @@ 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_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
builder_.add_any_ambiguous(any_ambiguous);
@@ -2065,7 +2088,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
flatbuffers::Offset<void> any_ambiguous = 0,
const std::vector<uint8_t> *vector_of_enums = nullptr,
MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr) {
const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr,
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr) {
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;
@@ -2086,6 +2110,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<uint8_t>(*vector_of_enums) : 0;
auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Stat>(scalar_key_sorted_tables) : 0;
return MyGame::Example::CreateMonster(
_fbb,
pos,
@@ -2136,7 +2161,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
any_ambiguous,
vector_of_enums__,
signed_enum,
testrequirednestedflatbuffer__);
testrequirednestedflatbuffer__,
scalar_key_sorted_tables__);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2611,6 +2637,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<MyGame::Example::Color>(_e->Get(_i)); } } }
{ auto _e = signed_enum(); _o->signed_enum = _e; }
{ auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
{ auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scalar_key_sorted_tables[_i] = flatbuffers::unique_ptr<MyGame::Example::StatT>(_e->Get(_i)->UnPack(_resolver)); } } }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2670,6 +2697,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast<uint8_t>(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0;
auto _signed_enum = _o->signed_enum;
auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2720,7 +2748,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_any_ambiguous,
_vector_of_enums,
_signed_enum,
_testrequirednestedflatbuffer);
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3408,7 +3437,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 0, 10 },
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 }
{ flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 5 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3474,10 +3504,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"any_ambiguous",
"vector_of_enums",
"signed_enum",
"testrequirednestedflatbuffer"
"testrequirednestedflatbuffer",
"scalar_key_sorted_tables"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 50, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 51, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

49
tests/monster_test_generated.js
View File

@@ -1929,11 +1929,29 @@ MyGame.Example.Monster.prototype.testrequirednestedflatbufferArray = function()
return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};
/**
* @param {number} index
* @param {MyGame.Example.Stat=} obj
* @returns {MyGame.Example.Stat}
*/
MyGame.Example.Monster.prototype.scalarKeySortedTables = function(index, obj) {
var offset = this.bb.__offset(this.bb_pos, 104);
return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};
/**
* @returns {number}
*/
MyGame.Example.Monster.prototype.scalarKeySortedTablesLength = function() {
var offset = this.bb.__offset(this.bb_pos, 104);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};
/**
* @param {flatbuffers.Builder} builder
*/
MyGame.Example.Monster.startMonster = function(builder) {
builder.startObject(50);
builder.startObject(51);
};
/**
@@ -2688,6 +2706,35 @@ MyGame.Example.Monster.startTestrequirednestedflatbufferVector = function(builde
builder.startVector(1, numElems, 1);
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Offset} scalarKeySortedTablesOffset
*/
MyGame.Example.Monster.addScalarKeySortedTables = function(builder, scalarKeySortedTablesOffset) {
builder.addFieldOffset(50, scalarKeySortedTablesOffset, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {Array.<flatbuffers.Offset>} data
* @returns {flatbuffers.Offset}
*/
MyGame.Example.Monster.createScalarKeySortedTablesVector = function(builder, data) {
builder.startVector(4, data.length, 4);
for (var i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} numElems
*/
MyGame.Example.Monster.startScalarKeySortedTablesVector = function(builder, numElems) {
builder.startVector(4, numElems, 4);
};
/**
* @param {flatbuffers.Builder} builder
* @returns {flatbuffers.Offset}

16
tests/monster_test_generated.lobster
View File

@@ -364,13 +364,17 @@ class Monster : flatbuffers_handle
return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 102) + i * 1)
def testrequirednestedflatbuffer_length():
return buf_.flatbuffers_field_vector_len(pos_, 102)
def scalar_key_sorted_tables(i:int):
return MyGame_Example_Stat { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 104) + i * 4) }
def scalar_key_sorted_tables_length():
return buf_.flatbuffers_field_vector_len(pos_, 104)
def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
struct MonsterBuilder:
b_:flatbuffers_builder
def start():
b_.StartObject(50)
b_.StartObject(51)
return this
def add_pos(pos:flatbuffers_offset):
b_.PrependStructSlot(0, pos)
@@ -519,6 +523,9 @@ struct MonsterBuilder:
def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers_offset):
b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer)
return this
def add_scalar_key_sorted_tables(scalar_key_sorted_tables:flatbuffers_offset):
b_.PrependUOffsetTRelativeSlot(50, scalar_key_sorted_tables)
return this
def end():
return b_.EndObject()
@@ -643,6 +650,13 @@ def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers_builder, v_:[
reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length)
def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers_builder, n_:int):
b_.StartVector(4, n_, 4)
def MonsterCreateScalarKeySortedTablesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]):
b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length)
class TypeAliases : flatbuffers_handle
def i8():
return buf_.flatbuffers_field_int8(pos_, 4, 0)

24
tests/monster_test_generated.rs
View File

@@ -1082,6 +1082,16 @@ impl<'a> Stat<'a> {
pub fn count(&self) -> u16 {
self._tab.get::<u16>(Stat::VT_COUNT, Some(0)).unwrap()
}
#[inline]
pub fn key_compare_less_than(&self, o: &Stat) -> bool {
self.count() < o.count()
}
#[inline]
pub fn key_compare_with_value(&self, val: u16) -> ::std::cmp::Ordering {
let key = self.count();
key.cmp(&val)
}
}
impl flatbuffers::Verifiable for Stat<'_> {
@@ -1300,6 +1310,7 @@ 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);
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); }
if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
if let Some(x) = args.any_ambiguous { builder.add_any_ambiguous(x); }
@@ -1394,6 +1405,7 @@ impl<'a> Monster<'a> {
pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104;
#[inline]
pub fn pos(&self) -> Option<&'a Vec3> {
@@ -1616,6 +1628,10 @@ impl<'a> Monster<'a> {
})
}
#[inline]
pub fn scalar_key_sorted_tables(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat>>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -1781,6 +1797,7 @@ impl flatbuffers::Verifiable for Monster<'_> {
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Color>>>(&"vector_of_enums", Self::VT_VECTOR_OF_ENUMS, false)?
.visit_field::<Race>(&"signed_enum", Self::VT_SIGNED_ENUM, false)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(&"testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Stat>>>>(&"scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)?
.finish();
Ok(())
}
@@ -1835,6 +1852,7 @@ pub struct MonsterArgs<'a> {
pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Color>>>,
pub signed_enum: Race,
pub testrequirednestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
pub scalar_key_sorted_tables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>>>,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -1889,6 +1907,7 @@ impl<'a> Default for MonsterArgs<'a> {
vector_of_enums: None,
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
scalar_key_sorted_tables: None,
}
}
}
@@ -2094,6 +2113,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
#[inline]
pub fn add_scalar_key_sorted_tables(&mut self, scalar_key_sorted_tables: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Stat<'b >>>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -2239,6 +2262,7 @@ impl std::fmt::Debug for Monster<'_> {
ds.field("vector_of_enums", &self.vector_of_enums());
ds.field("signed_enum", &self.signed_enum());
ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables());
ds.finish()
}
}

59
tests/monster_test_generated.ts
View File

@@ -2225,11 +2225,29 @@ testrequirednestedflatbufferArray():Uint8Array|null {
return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
};
/**
* @param number index
* @param MyGame.Example.Stat= obj
* @returns MyGame.Example.Stat
*/
scalarKeySortedTables(index: number, obj?:MyGame.Example.Stat):MyGame.Example.Stat|null {
var offset = this.bb!.__offset(this.bb_pos, 104);
return offset ? (obj || new MyGame.Example.Stat()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;
};
/**
* @returns number
*/
scalarKeySortedTablesLength():number {
var offset = this.bb!.__offset(this.bb_pos, 104);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
};
/**
* @param flatbuffers.Builder builder
*/
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(50);
builder.startObject(51);
};
/**
@@ -2989,6 +3007,35 @@ static startTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, numE
builder.startVector(1, numElems, 1);
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset scalarKeySortedTablesOffset
*/
static addScalarKeySortedTables(builder:flatbuffers.Builder, scalarKeySortedTablesOffset:flatbuffers.Offset) {
builder.addFieldOffset(50, scalarKeySortedTablesOffset, 0);
};
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createScalarKeySortedTablesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
builder.startVector(4, data.length, 4);
for (var i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
};
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startScalarKeySortedTablesVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(4, numElems, 4);
};
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
@@ -3089,7 +3136,8 @@ unpack(): MonsterT {
})(),
this.bb!.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()),
this.signedEnum(),
this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength())
this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength()),
this.bb!.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength())
);
};
@@ -3158,6 +3206,7 @@ unpackTo(_o: MonsterT): void {
_o.vectorOfEnums = this.bb!.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength());
_o.signedEnum = this.signedEnum();
_o.testrequirednestedflatbuffer = this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength());
_o.scalarKeySortedTables = this.bb!.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength());
};
}
@@ -3213,6 +3262,7 @@ export class MonsterT {
* @param (MyGame.Example.Color)[] vectorOfEnums
* @param MyGame.Example.Race signedEnum
* @param (number)[] testrequirednestedflatbuffer
* @param (MyGame.Example.StatT)[] scalarKeySortedTables
*/
constructor(
public pos: MyGame.Example.Vec3T|null = null,
@@ -3263,7 +3313,8 @@ constructor(
public anyAmbiguous: MyGame.Example.MonsterT|null = null,
public vectorOfEnums: (MyGame.Example.Color)[] = [],
public signedEnum: MyGame.Example.Race = MyGame.Example.Race.None,
public testrequirednestedflatbuffer: (number)[] = []
public testrequirednestedflatbuffer: (number)[] = [],
public scalarKeySortedTables: (MyGame.Example.StatT)[] = []
){};
/**
@@ -3294,6 +3345,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const anyAmbiguous = builder.createObjectOffset(this.anyAmbiguous);
const vectorOfEnums = MyGame.Example.Monster.createVectorOfEnumsVector(builder, this.vectorOfEnums);
const testrequirednestedflatbuffer = MyGame.Example.Monster.createTestrequirednestedflatbufferVector(builder, this.testrequirednestedflatbuffer);
const scalarKeySortedTables = MyGame.Example.Monster.createScalarKeySortedTablesVector(builder, builder.createObjectOffsetList(this.scalarKeySortedTables));
MyGame.Example.Monster.start(builder);
MyGame.Example.Monster.addPos(builder, (this.pos !== null ? this.pos!.pack(builder) : 0));
@@ -3345,6 +3397,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
MyGame.Example.Monster.addVectorOfEnums(builder, vectorOfEnums);
MyGame.Example.Monster.addSignedEnum(builder, this.signedEnum);
MyGame.Example.Monster.addTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer);
MyGame.Example.Monster.addScalarKeySortedTables(builder, scalarKeySortedTables);
return MyGame.Example.Monster.end(builder);
};

18
tests/monster_test_my_game.example_generated.dart
View File

@@ -802,10 +802,11 @@ class Monster {
List<Color> get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGet(_bc, _bcOffset, 98, null);
Race get signedEnum => new Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
List<int> get testrequirednestedflatbuffer => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 102, null);
List<Stat> get scalarKeySortedTables => const fb.ListReader<Stat>(Stat.reader).vTableGet(_bc, _bcOffset, 104, null);
@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}';
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}';
}
}
@@ -1024,6 +1025,10 @@ class MonsterBuilder {
fbBuilder.addOffset(49, offset);
return fbBuilder.offset;
}
int addScalarKeySortedTablesOffset(int offset) {
fbBuilder.addOffset(50, offset);
return fbBuilder.offset;
}
int finish() {
return fbBuilder.endTable();
@@ -1080,6 +1085,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final List<Color> _vectorOfEnums;
final Race _signedEnum;
final List<int> _testrequirednestedflatbuffer;
final List<StatObjectBuilder> _scalarKeySortedTables;
MonsterObjectBuilder({
Vec3ObjectBuilder pos,
@@ -1131,6 +1137,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
List<Color> vectorOfEnums,
Race signedEnum,
List<int> testrequirednestedflatbuffer,
List<StatObjectBuilder> scalarKeySortedTables,
})
: _pos = pos,
_mana = mana,
@@ -1180,7 +1187,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
_anyAmbiguous = anyAmbiguous,
_vectorOfEnums = vectorOfEnums,
_signedEnum = signedEnum,
_testrequirednestedflatbuffer = testrequirednestedflatbuffer;
_testrequirednestedflatbuffer = testrequirednestedflatbuffer,
_scalarKeySortedTables = scalarKeySortedTables;
/// Finish building, and store into the [fbBuilder].
@override
@@ -1251,6 +1259,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final int testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer?.isNotEmpty == true
? fbBuilder.writeListUint8(_testrequirednestedflatbuffer)
: null;
final int scalarKeySortedTablesOffset = _scalarKeySortedTables?.isNotEmpty == true
? fbBuilder.writeList(_scalarKeySortedTables.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
: null;
fbBuilder.startTable();
if (_pos != null) {
@@ -1356,6 +1367,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
if (testrequirednestedflatbufferOffset != null) {
fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
}
if (scalarKeySortedTablesOffset != null) {
fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
}
return fbBuilder.endTable();
}

6
tests/monsterdata_test.json
View File

@@ -75,4 +75,10 @@
testhashu32_fnv1a: "This string is being hashed!",
testhashs64_fnv1a: "This string is being hashed!",
testhashu64_fnv1a: "This string is being hashed!",
testarrayofsortedstruct:[
{id:5,distance:12}, {id:1,distance:21}, {id:0,distance:45}
],
scalar_key_sorted_tables:[
{id:"hit",val:10,count:1}, {id:"miss",val:0,count:0}
],
}

BIN
tests/monsterdata_test.mon
View File

Binary file not shown.

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

@@ -1662,8 +1662,8 @@ mod write_and_read_examples {
vector_of_non_owning_references: None, any_unique_type: NONE, \
any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None }, test4: Some([Test { \
a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None }, \
test4: Some([Test { a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
testarrayofstring: Some([\"test1\", \"test2\"]), \
testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
testempty: None, testbool: false, testhashs32_fnv1: 0, \
@@ -1680,7 +1680,7 @@ mod write_and_read_examples {
vector_of_non_owning_references: None, any_unique_type: NONE, \
any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None }"
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None }"
);
}

37
tests/test.cpp
View File

@@ -166,9 +166,18 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {
abilities.push_back(Ability(4, 40));
abilities.push_back(Ability(3, 30));
abilities.push_back(Ability(2, 20));
abilities.push_back(Ability(1, 10));
abilities.push_back(Ability(0, 0));
auto vecofstructs = builder.CreateVectorOfSortedStructs(&abilities);
flatbuffers::Offset<Stat> mlocs_stats[1];
auto miss = builder.CreateString("miss");
StatBuilder mb_miss(builder);
mb_miss.add_id(miss);
mb_miss.add_val(0);
mb_miss.add_count(0); // key
mlocs_stats[0] = mb_miss.Finish();
auto vec_of_stats = builder.CreateVectorOfSortedTables(mlocs_stats, 1);
// Create a nested FlatBuffer.
// Nested FlatBuffers are stored in a ubyte vector, which can be convenient
// since they can be memcpy'd around much easier than other FlatBuffer
@@ -210,7 +219,8 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {
testv, vecofstrings, vecoftables, 0, nested_flatbuffer_vector, 0, false,
0, 0, 0, 0, 0, 0, 0, 0, 0, 3.14159f, 3.0f, 0.0f, vecofstrings2,
vecofstructs, flex, testv2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
AnyUniqueAliases_NONE, 0, AnyAmbiguousAliases_NONE, 0, vecofcolors);
AnyUniqueAliases_NONE, 0, AnyAmbiguousAliases_NONE, 0, vecofcolors,
MyGame::Example::Race_None, 0, vec_of_stats);
FinishMonsterBuffer(builder, mloc);
@@ -361,11 +371,20 @@ void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length,
auto right = vecofstructs->Get(i + 1);
TEST_EQ(true, (left->KeyCompareLessThan(right)));
}
TEST_NOTNULL(vecofstructs->LookupByKey(0)); // test default value
TEST_NOTNULL(vecofstructs->LookupByKey(3));
TEST_EQ(static_cast<const Ability *>(nullptr),
vecofstructs->LookupByKey(5));
}
if (auto vec_of_stat = monster->scalar_key_sorted_tables()) {
auto stat_0 = vec_of_stat->LookupByKey(static_cast<uint16_t>(0u));
TEST_NOTNULL(stat_0);
TEST_NOTNULL(stat_0->id());
TEST_EQ(0, stat_0->count());
TEST_EQ_STR("miss", stat_0->id()->c_str());
}
// Test nested FlatBuffers if available:
auto nested_buffer = monster->testnestedflatbuffer();
if (nested_buffer) {
@@ -1088,12 +1107,13 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
"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 ], "
"testarrayofstring2: [ \"jane\", \"mary\" ], "
"testarrayofsortedstruct: [ { id: 1, distance: 10 }, "
"testarrayofsortedstruct: [ { id: 0, distance: 0 }, "
"{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "
"{ id: 4, distance: 40 } ], "
"flex: [ 210, 4, 5, 2 ], "
"test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "
"vector_of_enums: [ Blue, Green ] "
"vector_of_enums: [ Blue, Green ], "
"scalar_key_sorted_tables: [ { id: \"miss\" } ] "
"}");
Test test(16, 32);
@@ -2134,6 +2154,15 @@ void GenerateTableTextTest() {
TEST_EQ(ok, true);
// Test root table
const Monster *monster = GetMonster(parser.builder_.GetBufferPointer());
const auto abilities = monster->testarrayofsortedstruct();
TEST_EQ(abilities->size(), 3);
TEST_EQ(abilities->Get(0)->id(), 0);
TEST_EQ(abilities->Get(0)->distance(), 45);
TEST_EQ(abilities->Get(1)->id(), 1);
TEST_EQ(abilities->Get(1)->distance(), 21);
TEST_EQ(abilities->Get(2)->id(), 5);
TEST_EQ(abilities->Get(2)->distance(), 12);
std::string jsongen;
auto result = GenerateTextFromTable(parser, monster, "MyGame.Example.Monster",
&jsongen);