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

fixed comparator for native_inline (#7076)

Browse Source 
* fixed comparator for native_inline

* added native_inline data

* updated more tests for the new field

* more fixes
This commit is contained in:
Derek Bailey
2022-02-02 23:44:43 -08:00
committed by GitHub
parent 826193ff68
commit 39c8a19ce2
26 changed files with 937 additions and 636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1086,6 +1086,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
case signedEnum = 100
case testrequirednestedflatbuffer = 102
case scalarKeySortedTables = 104
case nativeInline = 106
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
@@ -1210,7 +1211,9 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
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 var nativeInline: MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.nativeInline.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_Test.self, at: o) }
public var mutableNativeInline: MyGame_Example_Test_Mutable? { let o = _accessor.offset(VTOFFSET.nativeInline.v); return o == 0 ? nil : MyGame_Example_Test_Mutable(_accessor.bb, o: o + _accessor.postion) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 52) }
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) }
@@ -1271,6 +1274,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
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, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VTOFFSET.testrequirednestedflatbuffer.p) }
public static func addVectorOf(scalarKeySortedTables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: scalarKeySortedTables, at: VTOFFSET.scalarKeySortedTables.p) }
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 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,
@@ -1323,7 +1327,8 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
vectorOfEnumsVectorOffset vectorOfEnums: Offset = Offset(),
signedEnum: MyGame_Example_Race = .none_,
testrequirednestedflatbufferVectorOffset testrequirednestedflatbuffer: Offset = Offset(),
scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset()
scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
nativeInline: MyGame_Example_Test? = nil
) -> Offset {
let __start = MyGame_Example_Monster.startMonster(&fbb)
MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1376,6 +1381,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
MyGame_Example_Monster.add(signedEnum: signedEnum, &fbb)
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: testrequirednestedflatbuffer, &fbb)
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: scalarKeySortedTables, &fbb)
MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
return MyGame_Example_Monster.endMonster(&fbb, start: __start)
}
public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
@@ -1532,6 +1538,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: __scalarKeySortedTables, &builder)
MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
return MyGame_Example_Monster.endMonster(&builder, start: __root)
}
@@ -1617,6 +1624,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
try _v.visit(field: VTOFFSET.signedEnum.p, fieldName: "signedEnum", required: false, type: MyGame_Example_Race.self)
try _v.visit(field: VTOFFSET.testrequirednestedflatbuffer.p, fieldName: "testrequirednestedflatbuffer", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
try _v.visit(field: VTOFFSET.scalarKeySortedTables.p, fieldName: "scalarKeySortedTables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Stat>, MyGame_Example_Stat>>.self)
try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
_v.finish()
}
}
@@ -1674,6 +1682,7 @@ extension MyGame_Example_Monster: Encodable {
case signedEnum = "signed_enum"
case testrequirednestedflatbuffer = "testrequirednestedflatbuffer"
case scalarKeySortedTables = "scalar_key_sorted_tables"
case nativeInline = "native_inline"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
@@ -1884,6 +1893,7 @@ extension MyGame_Example_Monster: Encodable {
try contentEncoder.encode(type)
}
}
try container.encodeIfPresent(nativeInline, forKey: .nativeInline)
}
}
@@ -1936,6 +1946,7 @@ public class MyGame_Example_MonsterT: NativeObject {
public var signedEnum: MyGame_Example_Race
public var testrequirednestedflatbuffer: [UInt8]
public var scalarKeySortedTables: [MyGame_Example_StatT?]
public var nativeInline: MyGame_Example_Test?
public init(_ _t: inout MyGame_Example_Monster) {
pos = _t.pos
@@ -2085,6 +2096,7 @@ public class MyGame_Example_MonsterT: NativeObject {
var __v_ = _t.scalarKeySortedTables(at: index)
scalarKeySortedTables.append(__v_?.unpack())
}
nativeInline = _t.nativeInline
}
public init() {
@@ -2132,6 +2144,7 @@ public class MyGame_Example_MonsterT: NativeObject {
signedEnum = .none_
testrequirednestedflatbuffer = []
scalarKeySortedTables = []
nativeInline = MyGame_Example_Test()
}
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

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

@@ -210,6 +210,7 @@ public struct Monster : IFlatbufferObject
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 MyGame.Example.Test? NativeInline { get { int o = __p.__offset(106); return o != 0 ? (MyGame.Example.Test?)(new MyGame.Example.Test()).__assign(o + __p.bb_pos, __p.bb) : null; } }
public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
MyGame.Example.Vec3T pos = null,
@@ -261,8 +262,9 @@ public struct Monster : IFlatbufferObject
VectorOffset vector_of_enumsOffset = default(VectorOffset),
MyGame.Example.Race signed_enum = MyGame.Example.Race.None,
VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset),
VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset)) {
builder.StartTable(51);
VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset),
MyGame.Example.TestT native_inline = null) {
builder.StartTable(52);
Monster.AddNonOwningReference(builder, non_owning_reference);
Monster.AddCoOwningReference(builder, co_owning_reference);
Monster.AddSingleWeakReference(builder, single_weak_reference);
@@ -270,6 +272,7 @@ public struct Monster : IFlatbufferObject
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
Monster.AddNativeInline(builder, MyGame.Example.Test.Pack(builder, native_inline));
Monster.AddScalarKeySortedTables(builder, scalar_key_sorted_tablesOffset);
Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
@@ -316,7 +319,7 @@ public struct Monster : IFlatbufferObject
return Monster.EndMonster(builder);
}
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(51); }
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(52); }
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); }
@@ -421,6 +424,7 @@ public struct Monster : IFlatbufferObject
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 void AddNativeInline(FlatBufferBuilder builder, Offset<MyGame.Example.Test> nativeInlineOffset) { builder.AddStruct(51, nativeInlineOffset.Value, 0); }
public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
int o = builder.EndTable();
builder.Required(o, 10); // name
@@ -566,6 +570,7 @@ public struct Monster : IFlatbufferObject
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);}
_o.NativeInline = this.NativeInline.HasValue ? this.NativeInline.Value.UnPack() : null;
}
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -739,7 +744,8 @@ public struct Monster : IFlatbufferObject
_vector_of_enums,
_o.SignedEnum,
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
_scalar_key_sorted_tables,
_o.NativeInline);
}
}
@@ -886,6 +892,8 @@ public class MonsterT
public List<byte> Testrequirednestedflatbuffer { get; set; }
[Newtonsoft.Json.JsonProperty("scalar_key_sorted_tables")]
public List<MyGame.Example.StatT> ScalarKeySortedTables { get; set; }
[Newtonsoft.Json.JsonProperty("native_inline")]
public MyGame.Example.TestT NativeInline { get; set; }
public MonsterT() {
this.Pos = new MyGame.Example.Vec3T();
@@ -935,6 +943,7 @@ public class MonsterT
this.SignedEnum = MyGame.Example.Race.None;
this.Testrequirednestedflatbuffer = null;
this.ScalarKeySortedTables = null;
this.NativeInline = new MyGame.Example.TestT();
}
public static MonsterT DeserializeFromJson(string jsonText) {

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

@@ -57,6 +57,7 @@ type MonsterT struct {
SignedEnum Race
Testrequirednestedflatbuffer []byte
ScalarKeySortedTables []*StatT
NativeInline *TestT
}
func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -313,6 +314,8 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
MonsterAddSignedEnum(builder, t.SignedEnum)
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset)
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTablesOffset)
nativeInlineOffset := t.NativeInline.Pack(builder)
MonsterAddNativeInline(builder, nativeInlineOffset)
return MonsterEnd(builder)
}
@@ -451,6 +454,7 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
rcv.ScalarKeySortedTables(&x, j)
t.ScalarKeySortedTables[j] = x.UnPack()
}
t.NativeInline = rcv.NativeInline(nil).UnPack()
}
func (rcv *Monster) UnPack() *MonsterT {
@@ -1339,8 +1343,21 @@ func (rcv *Monster) ScalarKeySortedTablesLength() int {
return 0
}
func (rcv *Monster) NativeInline(obj *Test) *Test {
o := flatbuffers.UOffsetT(rcv._tab.Offset(106))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(Test)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func MonsterStart(builder *flatbuffers.Builder) {
builder.StartObject(51)
builder.StartObject(52)
}
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1552,6 +1569,9 @@ func MonsterAddScalarKeySortedTables(builder *flatbuffers.Builder, scalarKeySort
func MonsterStartScalarKeySortedTablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func MonsterAddNativeInline(builder *flatbuffers.Builder, nativeInline flatbuffers.UOffsetT) {
builder.PrependStructSlot(51, flatbuffers.UOffsetT(nativeInline), 0)
}
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}

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

@@ -210,8 +210,10 @@ public final class Monster extends Table {
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 MyGame.Example.Test nativeInline() { return nativeInline(new MyGame.Example.Test()); }
public MyGame.Example.Test nativeInline(MyGame.Example.Test obj) { int o = __offset(106); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(51); }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(52); }
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); }
@@ -304,6 +306,7 @@ public final class Monster extends Table {
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 void addNativeInline(FlatBufferBuilder builder, int nativeInlineOffset) { builder.addStruct(51, nativeInlineOffset, 0); }
public static int endMonster(FlatBufferBuilder builder) {
int o = builder.endTable();
builder.required(o, 10); // name
@@ -518,6 +521,8 @@ public final class Monster extends Table {
MyGame.Example.StatT[] _oScalarKeySortedTables = new MyGame.Example.StatT[scalarKeySortedTablesLength()];
for (int _j = 0; _j < scalarKeySortedTablesLength(); ++_j) {_oScalarKeySortedTables[_j] = (scalarKeySortedTables(_j) != null ? scalarKeySortedTables(_j).unpack() : null);}
_o.setScalarKeySortedTables(_oScalarKeySortedTables);
if (nativeInline() != null) nativeInline().unpackTo(_o.getNativeInline());
else _o.setNativeInline(null);
}
public static int pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return 0;
@@ -704,6 +709,7 @@ public final class Monster extends Table {
addSignedEnum(builder, _o.getSignedEnum());
addTestrequirednestedflatbuffer(builder, _testrequirednestedflatbuffer);
addScalarKeySortedTables(builder, _scalarKeySortedTables);
addNativeInline(builder, MyGame.Example.Test.pack(builder, _o.getNativeInline()));
return endMonster(builder);
}
}

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

@@ -834,6 +834,15 @@ class Monster : Table() {
null
}
}
val nativeInline : MyGame.Example.Test? get() = nativeInline(MyGame.Example.Test())
fun nativeInline(obj: MyGame.Example.Test) : MyGame.Example.Test? {
val o = __offset(106)
return if (o != 0) {
obj.__assign(o + bb_pos, bb)
} else {
null
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
@@ -845,7 +854,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(51)
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(52)
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)
@@ -1035,6 +1044,7 @@ class Monster : Table() {
return builder.endVector()
}
fun startScalarKeySortedTablesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addNativeInline(builder: FlatBufferBuilder, nativeInline: Int) = builder.addStruct(51, nativeInline, 0)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)

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

@@ -677,8 +677,18 @@ function mt:ScalarKeySortedTablesLength()
return 0
end
function mt:NativeInline()
local o = self.view:Offset(106)
if o ~= 0 then
local x = self.view.pos + o
local obj = __MyGame_Example_Test.New()
obj:Init(self.view.bytes, x)
return obj
end
end
function Monster.Start(builder)
builder:StartObject(51)
builder:StartObject(52)
end
function Monster.AddPos(builder, pos)
@@ -961,6 +971,10 @@ function Monster.StartScalarKeySortedTablesVector(builder, numElems)
return builder:StartVector(4, numElems, 4)
end
function Monster.AddNativeInline(builder, nativeInline)
builder:PrependStructSlot(51, nativeInline, 0)
end
function Monster.End(builder)
return builder:EndObject()
end

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

@@ -729,22 +729,29 @@ class Monster extends Table
return $o != 0 ? $this->__vector_len($o) : 0;
}
public function getNativeInline()
{
$obj = new Test();
$o = $this->__offset(106);
return $o != 0 ? $obj->init($o + $this->bb_pos, $this->bb) : 0;
}
/**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMonster(FlatBufferBuilder $builder)
{
$builder->StartObject(51);
$builder->StartObject(52);
}
/**
* @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)
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)
{
$builder->startObject(51);
$builder->startObject(52);
self::addPos($builder, $pos);
self::addMana($builder, $mana);
self::addHp($builder, $hp);
@@ -795,6 +802,7 @@ class Monster extends Table
self::addSignedEnum($builder, $signed_enum);
self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
self::addScalarKeySortedTables($builder, $scalar_key_sorted_tables);
self::addNativeInline($builder, $native_inline);
$o = $builder->endObject();
$builder->required($o, 10); // name
return $o;
@@ -1765,6 +1773,16 @@ class Monster extends Table
$builder->startVector(4, $numElems, 4);
}
/**
* @param FlatBufferBuilder $builder
* @param int
* @return void
*/
public static function addNativeInline(FlatBufferBuilder $builder, $nativeInline)
{
$builder->addStructX(51, $nativeInline, 0);
}
/**
* @param FlatBufferBuilder $builder
* @return int table offset

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

@@ -791,7 +791,18 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
def MonsterStart(builder): builder.StartObject(51)
# Monster
def NativeInline(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
if o != 0:
x = o + self._tab.Pos
from MyGame.Example.Test import Test
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
return None
def MonsterStart(builder): builder.StartObject(52)
def Start(builder):
return MonsterStart(builder)
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
@@ -1018,6 +1029,9 @@ def AddScalarKeySortedTables(builder, scalarKeySortedTables):
def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartScalarKeySortedTablesVector(builder, numElems):
return MonsterStartScalarKeySortedTablesVector(builder, numElems)
def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
def AddNativeInline(builder, nativeInline):
return MonsterAddNativeInline(builder, nativeInline)
def MonsterEnd(builder): return builder.EndObject()
def End(builder):
return MonsterEnd(builder)
@@ -1091,6 +1105,7 @@ class MonsterT(object):
self.signedEnum = -1 # type: int
self.testrequirednestedflatbuffer = None # type: List[int]
self.scalarKeySortedTables = None # type: List[MyGame.Example.Stat.StatT]
self.nativeInline = None # type: Optional[MyGame.Example.Test.TestT]
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1283,6 +1298,8 @@ class MonsterT(object):
else:
stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
self.scalarKeySortedTables.append(stat_)
if monster.NativeInline() is not None:
self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
# MonsterT
def Pack(self, builder):
@@ -1531,5 +1548,8 @@ class MonsterT(object):
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
if self.nativeInline is not None:
nativeInline = self.nativeInline.Pack(builder)
MonsterAddNativeInline(builder, nativeInline)
monster = MonsterEnd(builder)
return monster

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

@@ -55,6 +55,7 @@ public class MonsterT {
private byte signedEnum;
private int[] testrequirednestedflatbuffer;
private MyGame.Example.StatT[] scalarKeySortedTables;
private MyGame.Example.TestT nativeInline;
public MyGame.Example.Vec3T getPos() { return pos; }
@@ -244,6 +245,10 @@ public class MonsterT {
public void setScalarKeySortedTables(MyGame.Example.StatT[] scalarKeySortedTables) { this.scalarKeySortedTables = scalarKeySortedTables; }
public MyGame.Example.TestT getNativeInline() { return nativeInline; }
public void setNativeInline(MyGame.Example.TestT nativeInline) { this.nativeInline = nativeInline; }
public MonsterT() {
this.pos = new MyGame.Example.Vec3T();
@@ -293,6 +298,7 @@ public class MonsterT {
this.signedEnum = -1;
this.testrequirednestedflatbuffer = null;
this.scalarKeySortedTables = null;
this.nativeInline = new MyGame.Example.TestT();
}
public static MonsterT deserializeFromBinary(byte[] fbBuffer) {
return Monster.getRootAsMonster(ByteBuffer.wrap(fbBuffer)).unpack();

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

@@ -1238,6 +1238,7 @@ struct MonsterT : public flatbuffers::NativeTable {
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{};
MyGame::Example::Test native_inline{};
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1302,7 +1303,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102,
VT_SCALAR_KEY_SORTED_TABLES = 104
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1641,6 +1643,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
}
const MyGame::Example::Test *native_inline() const {
return GetStruct<const MyGame::Example::Test *>(VT_NATIVE_INLINE);
}
MyGame::Example::Test *mutable_native_inline() {
return GetStruct<MyGame::Example::Test *>(VT_NATIVE_INLINE);
}
template<size_t Index>
auto get_field() const {
if constexpr (Index == 0) return pos();
@@ -1693,6 +1701,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
else if constexpr (Index == 47) return signed_enum();
else if constexpr (Index == 48) return testrequirednestedflatbuffer();
else if constexpr (Index == 49) return scalar_key_sorted_tables();
else if constexpr (Index == 50) return native_inline();
else static_assert(Index != Index, "Invalid Field Index");
}
bool Verify(flatbuffers::Verifier &verifier) const {
@@ -1783,6 +1792,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
verifier.VerifyVector(scalar_key_sorted_tables()) &&
verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1968,6 +1978,9 @@ struct MonsterBuilder {
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);
}
void add_native_inline(const MyGame::Example::Test *native_inline) {
fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -2031,7 +2044,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
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<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0) {
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -2040,6 +2054,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_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
@@ -2091,7 +2106,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 = 50;
static constexpr size_t fields_number = 51;
static constexpr std::array<const char *, fields_number> field_names = {
"pos",
"mana",
@@ -2142,7 +2157,8 @@ struct Monster::Traits {
"vector_of_enums",
"signed_enum",
"testrequirednestedflatbuffer",
"scalar_key_sorted_tables"
"scalar_key_sorted_tables",
"native_inline"
};
template<size_t Index>
using FieldType = decltype(std::declval<type>().get_field<Index>());
@@ -2199,7 +2215,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
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,
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr) {
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = 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;
@@ -2272,7 +2289,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
vector_of_enums__,
signed_enum,
testrequirednestedflatbuffer__,
scalar_key_sorted_tables__);
scalar_key_sorted_tables__,
native_inline);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2744,7 +2762,8 @@ inline MonsterT::MonsterT(const MonsterT &o)
any_ambiguous(o.any_ambiguous),
vector_of_enums(o.vector_of_enums),
signed_enum(o.signed_enum),
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer) {
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &v : o.testarrayoftables) { testarrayoftables.emplace_back((v) ? new MyGame::Example::MonsterT(*v) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2805,6 +2824,7 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(signed_enum, o.signed_enum);
std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer);
std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables);
std::swap(native_inline, o.native_inline);
return *this;
}
@@ -2874,6 +2894,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ 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++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = std::unique_ptr<MyGame::Example::StatT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2934,6 +2955,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
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;
auto _native_inline = &_o->native_inline;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2985,7 +3007,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_vector_of_enums,
_signed_enum,
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
_scalar_key_sorted_tables,
_native_inline);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3702,7 +3725,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 5 }
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3769,10 +3793,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"vector_of_enums",
"signed_enum",
"testrequirednestedflatbuffer",
"scalar_key_sorted_tables"
"scalar_key_sorted_tables",
"native_inline"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 51, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 52, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

BIN
tests/monster_test.bfbs
View File

Binary file not shown.

1
tests/monster_test.fbs
View File

@@ -124,6 +124,7 @@ table Monster {
signed_enum:Race = None (id:48);
testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: "Monster");
scalar_key_sorted_tables:[Stat] (id: 50);
native_inline:Test (id: 51, native_inline);
}
table TypeAliases {

3
tests/monster_test.schema.json
View File

@@ -318,6 +318,9 @@
},
"scalar_key_sorted_tables" : {
"type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_Stat"}
},
"native_inline" : {
"$ref" : "#/definitions/MyGame_Example_Test"
}
},
"required" : ["name"],

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

@@ -71,6 +71,7 @@ impl<'a> Monster<'a> {
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;
pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Monster"
@@ -93,6 +94,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.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); }
if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
@@ -292,6 +294,9 @@ impl<'a> Monster<'a> {
let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| {
x.iter().map(|t| t.unpack()).collect()
});
let native_inline = self.native_inline().map(|x| {
x.unpack()
});
MonsterT {
pos,
mana,
@@ -340,6 +345,7 @@ impl<'a> Monster<'a> {
signed_enum,
testrequirednestedflatbuffer,
scalar_key_sorted_tables,
native_inline,
}
}
@@ -568,6 +574,10 @@ impl<'a> Monster<'a> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat>>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)
}
#[inline]
pub fn native_inline(&self) -> Option<&'a Test> {
self._tab.get::<Test>(Monster::VT_NATIVE_INLINE, None)
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -734,6 +744,7 @@ impl flatbuffers::Verifiable for Monster<'_> {
.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)?
.visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
.finish();
Ok(())
}
@@ -789,6 +800,7 @@ pub struct MonsterArgs<'a> {
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>>>>>,
pub native_inline: Option<&'a Test>,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -844,6 +856,7 @@ impl<'a> Default for MonsterArgs<'a> {
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
scalar_key_sorted_tables: None,
native_inline: None,
}
}
}
@@ -1054,6 +1067,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
}
#[inline]
pub fn add_native_inline(&mut self, native_inline: &Test) {
self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -1200,6 +1217,7 @@ impl std::fmt::Debug for Monster<'_> {
ds.field("signed_enum", &self.signed_enum());
ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables());
ds.field("native_inline", &self.native_inline());
ds.finish()
}
}
@@ -1253,6 +1271,7 @@ pub struct MonsterT {
pub signed_enum: Race,
pub testrequirednestedflatbuffer: Option<Vec<u8>>,
pub scalar_key_sorted_tables: Option<Vec<StatT>>,
pub native_inline: Option<TestT>,
}
impl Default for MonsterT {
fn default() -> Self {
@@ -1304,6 +1323,7 @@ impl Default for MonsterT {
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
scalar_key_sorted_tables: None,
native_inline: None,
}
}
}
@@ -1412,6 +1432,8 @@ impl MonsterT {
let scalar_key_sorted_tables = self.scalar_key_sorted_tables.as_ref().map(|x|{
let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
});
let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack());
let native_inline = native_inline_tmp.as_ref();
Monster::create(_fbb, &MonsterArgs{
pos,
mana,
@@ -1463,6 +1485,7 @@ impl MonsterT {
signed_enum,
testrequirednestedflatbuffer,
scalar_key_sorted_tables,
native_inline,
})
}
}

1140
tests/monster_test_bfbs_generated.h
View File

File diff suppressed because it is too large Load Diff

44
tests/monster_test_generated.h
View File

@@ -1233,6 +1233,7 @@ struct MonsterT : public flatbuffers::NativeTable {
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{};
MyGame::Example::Test native_inline{};
MonsterT() = default;
MonsterT(const MonsterT &o);
MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1296,7 +1297,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102,
VT_SCALAR_KEY_SORTED_TABLES = 104
VT_SCALAR_KEY_SORTED_TABLES = 104,
VT_NATIVE_INLINE = 106
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1635,6 +1637,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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);
}
const MyGame::Example::Test *native_inline() const {
return GetStruct<const MyGame::Example::Test *>(VT_NATIVE_INLINE);
}
MyGame::Example::Test *mutable_native_inline() {
return GetStruct<MyGame::Example::Test *>(VT_NATIVE_INLINE);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1723,6 +1731,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
verifier.VerifyVector(scalar_key_sorted_tables()) &&
verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1908,6 +1917,9 @@ struct MonsterBuilder {
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);
}
void add_native_inline(const MyGame::Example::Test *native_inline) {
fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1971,7 +1983,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
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<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0) {
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
const MyGame::Example::Test *native_inline = nullptr) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -1980,6 +1993,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_native_inline(native_inline);
builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
@@ -2077,7 +2091,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
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,
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr) {
std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
const MyGame::Example::Test *native_inline = 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;
@@ -2150,7 +2165,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
vector_of_enums__,
signed_enum,
testrequirednestedflatbuffer__,
scalar_key_sorted_tables__);
scalar_key_sorted_tables__,
native_inline);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2643,7 +2659,8 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.vector_of_enums == rhs.vector_of_enums) &&
(lhs.signed_enum == rhs.signed_enum) &&
(lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer) &&
(lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables);
(lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables) &&
(lhs.native_inline == rhs.native_inline);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2693,7 +2710,8 @@ inline MonsterT::MonsterT(const MonsterT &o)
any_ambiguous(o.any_ambiguous),
vector_of_enums(o.vector_of_enums),
signed_enum(o.signed_enum),
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer) {
testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
native_inline(o.native_inline) {
testarrayoftables.reserve(o.testarrayoftables.size());
for (const auto &v : o.testarrayoftables) { testarrayoftables.emplace_back((v) ? new MyGame::Example::MonsterT(*v) : nullptr); }
vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2754,6 +2772,7 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
std::swap(signed_enum, o.signed_enum);
std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer);
std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables);
std::swap(native_inline, o.native_inline);
return *this;
}
@@ -2823,6 +2842,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ 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++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = flatbuffers::unique_ptr<MyGame::Example::StatT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
{ auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2883,6 +2903,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
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;
auto _native_inline = &_o->native_inline;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2934,7 +2955,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_vector_of_enums,
_signed_enum,
_testrequirednestedflatbuffer,
_scalar_key_sorted_tables);
_scalar_key_sorted_tables,
_native_inline);
}
@@ -3673,7 +3695,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 5 }
{ flatbuffers::ET_SEQUENCE, 1, 5 },
{ flatbuffers::ET_SEQUENCE, 0, 3 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3740,10 +3763,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"vector_of_enums",
"signed_enum",
"testrequirednestedflatbuffer",
"scalar_key_sorted_tables"
"scalar_key_sorted_tables",
"native_inline"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 51, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 52, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

8
tests/monster_test_generated.lobster
View File

@@ -392,13 +392,16 @@ class Monster : flatbuffers_handle
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 native_inline():
let o = buf_.flatbuffers_field_struct(pos_, 106)
return if o: MyGame_Example_Test { buf_, o } else: nil
def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
struct MonsterBuilder:
b_:flatbuffers_builder
def start():
b_.StartObject(51)
b_.StartObject(52)
return this
def add_pos(pos:flatbuffers_offset):
b_.PrependStructSlot(0, pos)
@@ -550,6 +553,9 @@ struct MonsterBuilder:
def add_scalar_key_sorted_tables(scalar_key_sorted_tables:flatbuffers_offset):
b_.PrependUOffsetTRelativeSlot(50, scalar_key_sorted_tables)
return this
def add_native_inline(native_inline:flatbuffers_offset):
b_.PrependStructSlot(51, native_inline)
return this
def end():
return b_.EndObject()

19
tests/monster_test_generated.py
View File

@@ -1468,7 +1468,17 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
def MonsterStart(builder): builder.StartObject(51)
# Monster
def NativeInline(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
if o != 0:
x = o + self._tab.Pos
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
return None
def MonsterStart(builder): builder.StartObject(52)
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)
@@ -1549,6 +1559,7 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, 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 MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
def MonsterEnd(builder): return builder.EndObject()
try:
@@ -1610,6 +1621,7 @@ class MonsterT(object):
self.signedEnum = -1 # type: int
self.testrequirednestedflatbuffer = None # type: List[int]
self.scalarKeySortedTables = None # type: List[StatT]
self.nativeInline = None # type: Optional[TestT]
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1802,6 +1814,8 @@ class MonsterT(object):
else:
stat_ = StatT.InitFromObj(monster.ScalarKeySortedTables(i))
self.scalarKeySortedTables.append(stat_)
if monster.NativeInline() is not None:
self.nativeInline = TestT.InitFromObj(monster.NativeInline())
# MonsterT
def Pack(self, builder):
@@ -2050,6 +2064,9 @@ class MonsterT(object):
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
if self.nativeInline is not None:
nativeInline = self.nativeInline.Pack(builder)
MonsterAddNativeInline(builder, nativeInline)
monster = MonsterEnd(builder)
return monster

33
tests/monster_test_my_game.example_generated.dart
View File

@@ -1115,10 +1115,11 @@ class Monster {
Race get signedEnum => Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
List<int>? get testrequirednestedflatbuffer => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 102);
List<Stat>? get scalarKeySortedTables => const fb.ListReader<Stat>(Stat.reader).vTableGetNullable(_bc, _bcOffset, 104);
Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
@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}';
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}';
}
MonsterT unpack() => MonsterT(
@@ -1171,7 +1172,8 @@ class Monster {
vectorOfEnums: const fb.ListReader<Color>(Color.reader, lazy: false).vTableGetNullable(_bc, _bcOffset, 98),
signedEnum: signedEnum,
testrequirednestedflatbuffer: const fb.Uint8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 102),
scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList());
scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList(),
nativeInline: nativeInline?.unpack());
static int pack(fb.Builder fbBuilder, MonsterT? object) {
if (object == null) return 0;
@@ -1233,6 +1235,7 @@ class MonsterT implements fb.Packable {
Race signedEnum;
List<int>? testrequirednestedflatbuffer;
List<StatT>? scalarKeySortedTables;
TestT? nativeInline;
MonsterT({
this.pos,
@@ -1284,7 +1287,8 @@ class MonsterT implements fb.Packable {
this.vectorOfEnums,
this.signedEnum = Race.None,
this.testrequirednestedflatbuffer,
this.scalarKeySortedTables});
this.scalarKeySortedTables,
this.nativeInline});
@override
int pack(fb.Builder fbBuilder) {
@@ -1345,7 +1349,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(50);
fbBuilder.startTable(51);
if (pos != null) {
fbBuilder.addStruct(0, pos!.pack(fbBuilder));
}
@@ -1398,12 +1402,15 @@ class MonsterT implements fb.Packable {
fbBuilder.addInt8(48, signedEnum.value);
fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
if (nativeInline != null) {
fbBuilder.addStruct(51, nativeInline!.pack(fbBuilder));
}
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}';
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}';
}
}
@@ -1421,7 +1428,7 @@ class MonsterBuilder {
final fb.Builder fbBuilder;
void begin() {
fbBuilder.startTable(50);
fbBuilder.startTable(51);
}
int addPos(int offset) {
@@ -1624,6 +1631,10 @@ class MonsterBuilder {
fbBuilder.addOffset(50, offset);
return fbBuilder.offset;
}
int addNativeInline(int offset) {
fbBuilder.addStruct(51, offset);
return fbBuilder.offset;
}
int finish() {
return fbBuilder.endTable();
@@ -1681,6 +1692,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final Race? _signedEnum;
final List<int>? _testrequirednestedflatbuffer;
final List<StatObjectBuilder>? _scalarKeySortedTables;
final TestObjectBuilder? _nativeInline;
MonsterObjectBuilder({
Vec3ObjectBuilder? pos,
@@ -1733,6 +1745,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
Race? signedEnum,
List<int>? testrequirednestedflatbuffer,
List<StatObjectBuilder>? scalarKeySortedTables,
TestObjectBuilder? nativeInline,
})
: _pos = pos,
_mana = mana,
@@ -1783,7 +1796,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
_vectorOfEnums = vectorOfEnums,
_signedEnum = signedEnum,
_testrequirednestedflatbuffer = testrequirednestedflatbuffer,
_scalarKeySortedTables = scalarKeySortedTables;
_scalarKeySortedTables = scalarKeySortedTables,
_nativeInline = nativeInline;
/// Finish building, and store into the [fbBuilder].
@override
@@ -1836,7 +1850,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(50);
fbBuilder.startTable(51);
if (_pos != null) {
fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
}
@@ -1889,6 +1903,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
fbBuilder.addInt8(48, _signedEnum?.value);
fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
if (_nativeInline != null) {
fbBuilder.addStruct(51, _nativeInline!.finish(fbBuilder));
}
return fbBuilder.endTable();
}

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

@@ -73,6 +73,7 @@ impl<'a> Monster<'a> {
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;
pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Monster"
@@ -95,6 +96,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.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); }
if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
@@ -294,6 +296,9 @@ impl<'a> Monster<'a> {
let scalar_key_sorted_tables = self.scalar_key_sorted_tables().map(|x| {
x.iter().map(|t| t.unpack()).collect()
});
let native_inline = self.native_inline().map(|x| {
x.unpack()
});
MonsterT {
pos,
mana,
@@ -342,6 +347,7 @@ impl<'a> Monster<'a> {
signed_enum,
testrequirednestedflatbuffer,
scalar_key_sorted_tables,
native_inline,
}
}
@@ -570,6 +576,10 @@ impl<'a> Monster<'a> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat>>>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, None)
}
#[inline]
pub fn native_inline(&self) -> Option<&'a Test> {
self._tab.get::<Test>(Monster::VT_NATIVE_INLINE, None)
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -736,6 +746,7 @@ impl flatbuffers::Verifiable for Monster<'_> {
.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)?
.visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
.finish();
Ok(())
}
@@ -791,6 +802,7 @@ pub struct MonsterArgs<'a> {
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>>>>>,
pub native_inline: Option<&'a Test>,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -846,6 +858,7 @@ impl<'a> Default for MonsterArgs<'a> {
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
scalar_key_sorted_tables: None,
native_inline: None,
}
}
}
@@ -855,7 +868,7 @@ impl Serialize for Monster<'_> {
where
S: Serializer,
{
let mut s = serializer.serialize_struct("Monster", 51)?;
let mut s = serializer.serialize_struct("Monster", 52)?;
if let Some(f) = self.pos() {
s.serialize_field("pos", &f)?;
} else {
@@ -1056,6 +1069,11 @@ impl Serialize for Monster<'_> {
} else {
s.skip_field("scalar_key_sorted_tables")?;
}
if let Some(f) = self.native_inline() {
s.serialize_field("native_inline", &f)?;
} else {
s.skip_field("native_inline")?;
}
s.end()
}
}
@@ -1266,6 +1284,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
}
#[inline]
pub fn add_native_inline(&mut self, native_inline: &Test) {
self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -1412,6 +1434,7 @@ impl std::fmt::Debug for Monster<'_> {
ds.field("signed_enum", &self.signed_enum());
ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables());
ds.field("native_inline", &self.native_inline());
ds.finish()
}
}
@@ -1465,6 +1488,7 @@ pub struct MonsterT {
pub signed_enum: Race,
pub testrequirednestedflatbuffer: Option<Vec<u8>>,
pub scalar_key_sorted_tables: Option<Vec<StatT>>,
pub native_inline: Option<TestT>,
}
impl Default for MonsterT {
fn default() -> Self {
@@ -1516,6 +1540,7 @@ impl Default for MonsterT {
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
scalar_key_sorted_tables: None,
native_inline: None,
}
}
}
@@ -1624,6 +1649,8 @@ impl MonsterT {
let scalar_key_sorted_tables = self.scalar_key_sorted_tables.as_ref().map(|x|{
let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
});
let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack());
let native_inline = native_inline_tmp.as_ref();
Monster::create(_fbb, &MonsterArgs{
pos,
mana,
@@ -1675,6 +1702,7 @@ impl MonsterT {
signed_enum,
testrequirednestedflatbuffer,
scalar_key_sorted_tables,
native_inline,
})
}
}

44
tests/monsterdata_test.json
View File

@@ -20,16 +20,16 @@
4
],
vector_of_longs: [
1,
100,
10000,
1000000,
100000000
1,
100,
10000,
1000000,
100000000
],
vector_of_doubles: [
-1.7976931348623157e+308,
0,
1.7976931348623157e+308
-1.7976931348623157e+308,
0,
1.7976931348623157e+308
],
test_type: "Monster",
test: {
@@ -63,8 +63,10 @@
enemy: {
name: "Fred"
},
testarrayofbools:[
true, false, true
testarrayofbools: [
true,
false,
true
],
testbool: true,
testhashs32_fnv1: "This string is being hashed!",
@@ -75,10 +77,22 @@
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}
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}
scalar_key_sorted_tables: [
{id: "hit",val: 10,count: 1
},
{id: "miss",val: 0,count: 0
}
],
}
native_inline: {
a: 1,
b: 2
}
}

BIN
tests/monsterdata_test.mon
View File

Binary file not shown.

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

@@ -646,12 +646,17 @@ scalarKeySortedTablesLength():number {
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
nativeInline(obj?:Test):Test|null {
const offset = this.bb!.__offset(this.bb_pos, 106);
return offset ? (obj || new Test()).__init(this.bb_pos + offset, this.bb!) : null;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Monster';
}
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(51);
builder.startObject(52);
}
static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) {
@@ -1075,6 +1080,10 @@ static startScalarKeySortedTablesVector(builder:flatbuffers.Builder, numElems:nu
builder.startVector(4, numElems, 4);
}
static addNativeInline(builder:flatbuffers.Builder, nativeInlineOffset:flatbuffers.Offset) {
builder.addFieldStruct(51, nativeInlineOffset, 0);
}
static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
builder.requiredField(offset, 10) // name
@@ -1161,7 +1170,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!.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength())
this.bb!.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()),
(this.nativeInline() !== null ? this.nativeInline()!.unpack() : null)
);
}
@@ -1229,6 +1239,7 @@ unpackTo(_o: MonsterT): void {
_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());
_o.nativeInline = (this.nativeInline() !== null ? this.nativeInline()!.unpack() : null);
}
}
@@ -1283,7 +1294,8 @@ constructor(
public vectorOfEnums: (Color)[] = [],
public signedEnum: Race = Race.None,
public testrequirednestedflatbuffer: (number)[] = [],
public scalarKeySortedTables: (StatT)[] = []
public scalarKeySortedTables: (StatT)[] = [],
public nativeInline: TestT|null = null
){}
@@ -1367,6 +1379,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
Monster.addSignedEnum(builder, this.signedEnum);
Monster.addTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer);
Monster.addScalarKeySortedTables(builder, scalarKeySortedTables);
Monster.addNativeInline(builder, (this.nativeInline !== null ? this.nativeInline!.pack(builder) : 0));
return Monster.endMonster(builder);
}

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

@@ -189,6 +189,7 @@ fn object_api_defaults() {
signed_enum: Race::None,
testrequirednestedflatbuffer: None, // despite the name, it is not required.
scalar_key_sorted_tables: None,
native_inline: None,
}
);
}
@@ -1829,7 +1830,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, scalar_key_sorted_tables: None }, \
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
native_inline: None }, \
test4: Some([Test { a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
testarrayofstring: Some([\"test1\", \"test2\"]), \
testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
@@ -1847,7 +1849,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, scalar_key_sorted_tables: None }"
testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
native_inline: None }"
);
}