BigfootDev/flatbuffers-bigfoot
1
0
Fork 0
forked from BigfootDev/flatbuffers
Code Pull Requests Activity

Added required-nested-flatbuffer to monster_test and fixed rust (#6236)

Browse Source 
Co-authored-by: Casper Neo <cneo@google.com>
This commit is contained in:
Casper
2020-11-05 13:58:06 -08:00
committed by GitHub
parent bc56c553ec
commit 46a8c7e958
21 changed files with 1047 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/idl_gen_rust.cpp
View File

@@ -1302,13 +1302,21 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("NESTED", WrapInNameSpace(*nested_root));
code_ +=
" pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> "
"Option<{{NESTED}}<'a>> {";
code_ += " self.{{FIELD_NAME}}().map(|data| {";
code_ += " use flatbuffers::Follow;";
code_ += " <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
"::follow(data, 0)";
code_ += " })";
" pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> \\";
if (field.required) {
code_ += "{{NESTED}}<'a> {";
code_ += " let data = self.{{FIELD_NAME}}();";
code_ += " use flatbuffers::Follow;";
code_ += " <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
"::follow(data, 0)";
} else {
code_ += "Option<{{NESTED}}<'a>> {";
code_ += " self.{{FIELD_NAME}}().map(|data| {";
code_ += " use flatbuffers::Follow;";
code_ += " <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
"::follow(data, 0)";
code_ += " })";
}
code_ += " }";
}
});

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

@@ -719,6 +719,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
case anyAmbiguous = 96
case vectorOfEnums = 98
case signedEnum = 100
case testrequirednestedflatbuffer = 102
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
@@ -832,7 +833,11 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
public func vectorOfEnums(at index: Int32) -> MyGame_Example_Color? { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? MyGame_Example_Color.red : MyGame_Example_Color(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
public var signedEnum: MyGame_Example_Race { let o = _accessor.offset(VTOFFSET.signedEnum.v); return o == 0 ? .none_ : MyGame_Example_Race(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
@discardableResult public func mutate(signedEnum: MyGame_Example_Race) -> Bool {let o = _accessor.offset(VTOFFSET.signedEnum.v); return _accessor.mutate(signedEnum.rawValue, index: o) }
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 49) }
public var testrequirednestedflatbufferCount: Int32 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.vector(count: o) }
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 static func add(pos: Offset<UOffset>?, _ fbb: inout FlatBufferBuilder) { guard pos != nil else { return }; fbb.add(structOffset: 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) }
@@ -891,6 +896,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
public static func add(anyAmbiguous: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VTOFFSET.anyAmbiguous.p) }
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 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 sortVectorOfMonster(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
var off = offsets
@@ -980,6 +986,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
let __anyUnique = obj.anyUnique?.pack(builder: &builder) ?? Offset()
let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
let __root = MyGame_Example_Monster.startMonster(&builder)
MyGame_Example_Monster.add(pos: obj.pos.map { MyGame_Example_Vec3.createVec3(builder: &builder, x: $0.x, y: $0.y, z: $0.z, test1: $0.test1, test2: $0.test2, test3a: $0.test3.a, test3b: $0.test3.b) }, &builder)
MyGame_Example_Monster.add(mana: obj.mana, &builder)
@@ -1038,6 +1045,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)
return MyGame_Example_Monster.endMonster(&builder, start: __root)
}
}
@@ -1089,6 +1097,7 @@ public class MyGame_Example_MonsterT: NativeTable {
public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
public var vectorOfEnums: [MyGame_Example_Color]
public var signedEnum: MyGame_Example_Race
public var testrequirednestedflatbuffer: [UInt8]
public init(_ _t: inout MyGame_Example_Monster) {
var __pos = _t.pos
@@ -1233,6 +1242,10 @@ public class MyGame_Example_MonsterT: NativeTable {
vectorOfEnums.append(_t.vectorOfEnums(at: index)!)
}
signedEnum = _t.signedEnum
testrequirednestedflatbuffer = []
for index in 0..<_t.testrequirednestedflatbufferCount {
testrequirednestedflatbuffer.append(_t.testrequirednestedflatbuffer(at: index))
}
}
public init() {
@@ -1278,6 +1291,7 @@ public class MyGame_Example_MonsterT: NativeTable {
vectorOfNonOwningReferences = []
vectorOfEnums = []
signedEnum = .none_
testrequirednestedflatbuffer = []
}
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

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

@@ -188,6 +188,16 @@ public struct Monster : IFlatbufferObject
public bool MutateVectorOfEnums(int j, MyGame.Example.Color vector_of_enums) { int o = __p.__offset(98); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
public MyGame.Example.Race SignedEnum { get { int o = __p.__offset(100); return o != 0 ? (MyGame.Example.Race)__p.bb.GetSbyte(o + __p.bb_pos) : MyGame.Example.Race.None; } }
public bool MutateSignedEnum(MyGame.Example.Race signed_enum) { int o = __p.__offset(100); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)signed_enum); return true; } else { return false; } }
public byte Testrequirednestedflatbuffer(int j) { int o = __p.__offset(102); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
public int TestrequirednestedflatbufferLength { get { int o = __p.__offset(102); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
public Span<byte> GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_span<byte>(102, 1); }
#else
public ArraySegment<byte>? GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_arraysegment(102); }
#endif
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 static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
MyGame.Example.Vec3T pos = null,
@@ -237,8 +247,9 @@ public struct Monster : IFlatbufferObject
MyGame.Example.AnyAmbiguousAliases any_ambiguous_type = MyGame.Example.AnyAmbiguousAliases.NONE,
int any_ambiguousOffset = 0,
VectorOffset vector_of_enumsOffset = default(VectorOffset),
MyGame.Example.Race signed_enum = MyGame.Example.Race.None) {
builder.StartTable(49);
MyGame.Example.Race signed_enum = MyGame.Example.Race.None,
VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset)) {
builder.StartTable(50);
Monster.AddNonOwningReference(builder, non_owning_reference);
Monster.AddCoOwningReference(builder, co_owning_reference);
Monster.AddSingleWeakReference(builder, single_weak_reference);
@@ -246,6 +257,7 @@ public struct Monster : IFlatbufferObject
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
Monster.AddAnyAmbiguous(builder, any_ambiguousOffset);
Monster.AddAnyUnique(builder, any_uniqueOffset);
@@ -290,7 +302,7 @@ public struct Monster : IFlatbufferObject
return Monster.EndMonster(builder);
}
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(49); }
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(50); }
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); }
@@ -387,6 +399,10 @@ public struct Monster : IFlatbufferObject
public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
public static void StartVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
public static void AddSignedEnum(FlatBufferBuilder builder, MyGame.Example.Race signedEnum) { builder.AddSbyte(48, (sbyte)signedEnum, -1); }
public static void AddTestrequirednestedflatbuffer(FlatBufferBuilder builder, VectorOffset testrequirednestedflatbufferOffset) { builder.AddOffset(49, testrequirednestedflatbufferOffset.Value, 0); }
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 Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
int o = builder.EndTable();
builder.Required(o, 10); // name
@@ -528,6 +544,8 @@ public struct Monster : IFlatbufferObject
_o.VectorOfEnums = new List<MyGame.Example.Color>();
for (var _j = 0; _j < this.VectorOfEnumsLength; ++_j) {_o.VectorOfEnums.Add(this.VectorOfEnums(_j));}
_o.SignedEnum = this.SignedEnum;
_o.Testrequirednestedflatbuffer = new List<byte>();
for (var _j = 0; _j < this.TestrequirednestedflatbufferLength; ++_j) {_o.Testrequirednestedflatbuffer.Add(this.Testrequirednestedflatbuffer(_j));}
}
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -639,6 +657,11 @@ public struct Monster : IFlatbufferObject
var __vector_of_enums = _o.VectorOfEnums.ToArray();
_vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
}
var _testrequirednestedflatbuffer = default(VectorOffset);
if (_o.Testrequirednestedflatbuffer != null) {
var __testrequirednestedflatbuffer = _o.Testrequirednestedflatbuffer.ToArray();
_testrequirednestedflatbuffer = CreateTestrequirednestedflatbufferVector(builder, __testrequirednestedflatbuffer);
}
return CreateMonster(
builder,
_o.Pos,
@@ -688,7 +711,8 @@ public struct Monster : IFlatbufferObject
_any_ambiguous_type,
_any_ambiguous,
_vector_of_enums,
_o.SignedEnum);
_o.SignedEnum,
_testrequirednestedflatbuffer);
}
};
@@ -831,6 +855,8 @@ public class MonsterT
public List<MyGame.Example.Color> VectorOfEnums { get; set; }
[Newtonsoft.Json.JsonProperty("signed_enum")]
public MyGame.Example.Race SignedEnum { get; set; }
[Newtonsoft.Json.JsonProperty("testrequirednestedflatbuffer")]
public List<byte> Testrequirednestedflatbuffer { get; set; }
public MonsterT() {
this.Pos = new MyGame.Example.Vec3T();
@@ -878,6 +904,7 @@ public class MonsterT
this.AnyAmbiguous = null;
this.VectorOfEnums = null;
this.SignedEnum = MyGame.Example.Race.None;
this.Testrequirednestedflatbuffer = null;
}
public static MonsterT DeserializeFromJson(string jsonText) {

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

@@ -55,6 +55,7 @@ type MonsterT struct {
AnyAmbiguous *AnyAmbiguousAliasesT
VectorOfEnums []Color
SignedEnum Race
Testrequirednestedflatbuffer []byte
}
func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -236,6 +237,10 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
}
vectorOfEnumsOffset = builder.EndVector(vectorOfEnumsLength)
}
testrequirednestedflatbufferOffset := flatbuffers.UOffsetT(0)
if t.Testrequirednestedflatbuffer != nil {
testrequirednestedflatbufferOffset = builder.CreateByteString(t.Testrequirednestedflatbuffer)
}
MonsterStart(builder)
posOffset := t.Pos.Pack(builder)
MonsterAddPos(builder, posOffset)
@@ -292,6 +297,7 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
MonsterAddAnyAmbiguous(builder, anyAmbiguousOffset)
MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset)
MonsterAddSignedEnum(builder, t.SignedEnum)
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset)
return MonsterEnd(builder)
}
@@ -422,6 +428,7 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
t.VectorOfEnums[j] = rcv.VectorOfEnums(j)
}
t.SignedEnum = rcv.SignedEnum()
t.Testrequirednestedflatbuffer = rcv.TestrequirednestedflatbufferBytes()
}
func (rcv *Monster) UnPack() *MonsterT {
@@ -1256,8 +1263,42 @@ func (rcv *Monster) MutateSignedEnum(n Race) bool {
return rcv._tab.MutateInt8Slot(100, int8(n))
}
func (rcv *Monster) Testrequirednestedflatbuffer(j int) byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
}
return 0
}
func (rcv *Monster) TestrequirednestedflatbufferLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func (rcv *Monster) TestrequirednestedflatbufferBytes() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *Monster) MutateTestrequirednestedflatbuffer(j int, n byte) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
if o != 0 {
a := rcv._tab.Vector(o)
return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
}
return false
}
func MonsterStart(builder *flatbuffers.Builder) {
builder.StartObject(49)
builder.StartObject(50)
}
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1457,6 +1498,12 @@ func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int)
func MonsterAddSignedEnum(builder *flatbuffers.Builder, signedEnum Race) {
builder.PrependInt8Slot(48, int8(signedEnum), -1)
}
func MonsterAddTestrequirednestedflatbuffer(builder *flatbuffers.Builder, testrequirednestedflatbuffer flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(49, flatbuffers.UOffsetT(testrequirednestedflatbuffer), 0)
}
func MonsterStartTestrequirednestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(1, numElems, 1)
}
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}

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

@@ -194,8 +194,17 @@ public final class Monster extends Table {
public boolean mutateVectorOfEnums(int j, int vector_of_enums) { int o = __offset(98); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
public byte signedEnum() { int o = __offset(100); return o != 0 ? bb.get(o + bb_pos) : -1; }
public boolean mutateSignedEnum(byte signed_enum) { int o = __offset(100); if (o != 0) { bb.put(o + bb_pos, signed_enum); return true; } else { return false; } }
public int testrequirednestedflatbuffer(int j) { int o = __offset(102); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
public int testrequirednestedflatbufferLength() { int o = __offset(102); return o != 0 ? __vector_len(o) : 0; }
public ByteVector testrequirednestedflatbufferVector() { return testrequirednestedflatbufferVector(new ByteVector()); }
public ByteVector testrequirednestedflatbufferVector(ByteVector obj) { int o = __offset(102); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer testrequirednestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(102, 1); }
public ByteBuffer testrequirednestedflatbufferInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 102, 1); }
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 static void startMonster(FlatBufferBuilder builder) { builder.startTable(49); }
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(50); }
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); }
@@ -281,6 +290,10 @@ public final class Monster extends Table {
public static int createVectorOfEnumsVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addSignedEnum(FlatBufferBuilder builder, byte signedEnum) { builder.addByte(48, signedEnum, -1); }
public static void addTestrequirednestedflatbuffer(FlatBufferBuilder builder, int testrequirednestedflatbufferOffset) { builder.addOffset(49, testrequirednestedflatbufferOffset, 0); }
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 int endMonster(FlatBufferBuilder builder) {
int o = builder.endTable();
builder.required(o, 10); // name

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

@@ -773,6 +773,38 @@ class Monster : Table() {
false
}
}
fun testrequirednestedflatbuffer(j: Int) : UByte {
val o = __offset(102)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val testrequirednestedflatbufferLength : Int
get() {
val o = __offset(102); return if (o != 0) __vector_len(o) else 0
}
val testrequirednestedflatbufferAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(102, 1)
fun testrequirednestedflatbufferInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 102, 1)
val testrequirednestedflatbufferAsMonster : MyGame.Example.Monster? get() = testrequirednestedflatbufferAsMonster(MyGame.Example.Monster())
fun testrequirednestedflatbufferAsMonster(obj: MyGame.Example.Monster) : MyGame.Example.Monster? {
val o = __offset(102)
return if (o != 0) {
obj.__assign(__indirect(__vector(o)), bb)
} else {
null
}
}
fun mutateTestrequirednestedflatbuffer(j: Int, testrequirednestedflatbuffer: UByte) : Boolean {
val o = __offset(102)
return if (o != 0) {
bb.put(__vector(o) + j * 1, testrequirednestedflatbuffer.toByte())
true
} else {
false
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
@@ -784,7 +816,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(49)
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(50)
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)
@@ -956,6 +988,15 @@ class Monster : Table() {
}
fun startVectorOfEnumsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addSignedEnum(builder: FlatBufferBuilder, signedEnum: Byte) = builder.addByte(48, signedEnum, -1)
fun addTestrequirednestedflatbuffer(builder: FlatBufferBuilder, testrequirednestedflatbuffer: Int) = builder.addOffset(49, testrequirednestedflatbuffer, 0)
fun createTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)

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

@@ -529,7 +529,22 @@ function Monster_mt:SignedEnum()
end
return -1
end
function Monster.Start(builder) builder:StartObject(49) end
function Monster_mt:Testrequirednestedflatbuffer(j)
local o = self.view:Offset(102)
if o ~= 0 then
local a = self.view:Vector(o)
return self.view:Get(flatbuffers.N.Uint8, a + ((j-1) * 1))
end
return 0
end
function Monster_mt:TestrequirednestedflatbufferLength()
local o = self.view:Offset(102)
if o ~= 0 then
return self.view:VectorLen(o)
end
return 0
end
function Monster.Start(builder) builder:StartObject(50) 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
@@ -596,6 +611,8 @@ function Monster.AddAnyAmbiguous(builder, anyAmbiguous) builder:PrependUOffsetTR
function Monster.AddVectorOfEnums(builder, vectorOfEnums) builder:PrependUOffsetTRelativeSlot(47, vectorOfEnums, 0) end
function Monster.StartVectorOfEnumsVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
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.End(builder) return builder:EndObject() end
return Monster -- return the module

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

@@ -683,22 +683,49 @@ class Monster extends Table
return $o != 0 ? $this->bb->getSbyte($o + $this->bb_pos) : \MyGame\Example\Race::None;
}
/**
* @param int offset
* @return byte
*/
public function getTestrequirednestedflatbuffer($j)
{
$o = $this->__offset(102);
return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
}
/**
* @return int
*/
public function getTestrequirednestedflatbufferLength()
{
$o = $this->__offset(102);
return $o != 0 ? $this->__vector_len($o) : 0;
}
/**
* @return string
*/
public function getTestrequirednestedflatbufferBytes()
{
return $this->__vector_as_bytes(102);
}
/**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMonster(FlatBufferBuilder $builder)
{
$builder->StartObject(49);
$builder->StartObject(50);
}
/**
* @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)
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)
{
$builder->startObject(49);
$builder->startObject(50);
self::addPos($builder, $pos);
self::addMana($builder, $mana);
self::addHp($builder, $hp);
@@ -747,6 +774,7 @@ class Monster extends Table
self::addAnyAmbiguous($builder, $any_ambiguous);
self::addVectorOfEnums($builder, $vector_of_enums);
self::addSignedEnum($builder, $signed_enum);
self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
$o = $builder->endObject();
$builder->required($o, 10); // name
return $o;
@@ -1649,6 +1677,40 @@ class Monster extends Table
$builder->addSbyteX(48, $signedEnum, -1);
}
/**
* @param FlatBufferBuilder $builder
* @param VectorOffset
* @return void
*/
public static function addTestrequirednestedflatbuffer(FlatBufferBuilder $builder, $testrequirednestedflatbuffer)
{
$builder->addOffsetX(49, $testrequirednestedflatbuffer, 0);
}
/**
* @param FlatBufferBuilder $builder
* @param array offset array
* @return int vector offset
*/
public static function createTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, array $data)
{
$builder->startVector(1, count($data), 1);
for ($i = count($data) - 1; $i >= 0; $i--) {
$builder->putByte($data[$i]);
}
return $builder->endVector();
}
/**
* @param FlatBufferBuilder $builder
* @param int $numElems
* @return void
*/
public static function startTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
{
$builder->startVector(1, $numElems, 1);
}
/**
* @param FlatBufferBuilder $builder
* @return int table offset

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

@@ -719,7 +719,34 @@ class Monster(object):
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
return -1
def MonsterStart(builder): builder.StartObject(49)
# Monster
def Testrequirednestedflatbuffer(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
a = self._tab.Vector(o)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
# Monster
def TestrequirednestedflatbufferAsNumpy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
# Monster
def TestrequirednestedflatbufferLength(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
return self._tab.VectorLen(o)
return 0
# Monster
def TestrequirednestedflatbufferIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
return o == 0
def MonsterStart(builder): builder.StartObject(50)
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)
@@ -786,6 +813,8 @@ def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelati
def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterEnd(builder): return builder.EndObject()
import MyGame.Example.Ability
@@ -856,6 +885,7 @@ class MonsterT(object):
self.anyAmbiguous = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
self.vectorOfEnums = None # type: List[int]
self.signedEnum = -1 # type: int
self.testrequirednestedflatbuffer = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
@@ -1033,6 +1063,13 @@ class MonsterT(object):
else:
self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
self.signedEnum = monster.SignedEnum()
if not monster.TestrequirednestedflatbufferIsNone():
if np is None:
self.testrequirednestedflatbuffer = []
for i in range(monster.TestrequirednestedflatbufferLength()):
self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
else:
self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
# MonsterT
def Pack(self, builder):
@@ -1185,6 +1222,14 @@ class MonsterT(object):
for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector(len(self.vectorOfEnums))
if self.testrequirednestedflatbuffer is not None:
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
else:
MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector(len(self.testrequirednestedflatbuffer))
MonsterStart(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
@@ -1261,5 +1306,7 @@ class MonsterT(object):
if self.vectorOfEnums is not None:
MonsterAddVectorOfEnums(builder, vectorOfEnums)
MonsterAddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None:
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
monster = MonsterEnd(builder)
return monster

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

@@ -1016,6 +1016,7 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{};
std::vector<MyGame::Example::Color> vector_of_enums{};
MyGame::Example::Race signed_enum = MyGame::Example::Race::None;
std::vector<uint8_t> testrequirednestedflatbuffer{};
};
/// an example documentation comment: "monster object"
@@ -1074,7 +1075,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_ANY_AMBIGUOUS_TYPE = 94,
VT_ANY_AMBIGUOUS = 96,
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1398,6 +1400,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_signed_enum(MyGame::Example::Race _signed_enum) {
return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
}
const flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
}
flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
}
const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1478,6 +1489,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
verifier.VerifyVector(vector_of_enums()) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1657,6 +1670,9 @@ struct MonsterBuilder {
void add_signed_enum(MyGame::Example::Race signed_enum) {
fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
}
void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1718,7 +1734,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
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) {
MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -1727,6 +1744,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_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
builder_.add_any_ambiguous(any_ambiguous);
builder_.add_any_unique(any_unique);
@@ -1825,7 +1843,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
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) {
MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
const std::vector<uint8_t> *testrequirednestedflatbuffer = 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;
@@ -1845,6 +1864,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
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;
return MyGame::Example::CreateMonster(
_fbb,
pos,
@@ -1894,7 +1914,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
any_ambiguous_type,
any_ambiguous,
vector_of_enums__,
signed_enum);
signed_enum,
testrequirednestedflatbuffer__);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2353,6 +2374,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
{ 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()); } }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2411,6 +2433,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
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;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2460,7 +2483,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_any_ambiguous_type,
_any_ambiguous,
_vector_of_enums,
_signed_enum);
_signed_enum,
_testrequirednestedflatbuffer);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3147,7 +3171,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_UTYPE, 0, 10 },
{ flatbuffers::ET_SEQUENCE, 0, 10 },
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 }
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3212,10 +3237,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"any_ambiguous_type",
"any_ambiguous",
"vector_of_enums",
"signed_enum"
"signed_enum",
"testrequirednestedflatbuffer"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 49, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 50, 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

@@ -116,6 +116,7 @@ table Monster {
any_ambiguous:AnyAmbiguousAliases (id:46);
vector_of_enums:[Color] (id:47);
signed_enum:Race = None (id:48);
testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: "Monster");
}
table TypeAliases {

3
tests/monster_test.schema.json
View File

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

1001
tests/monster_test_bfbs_generated.h
View File

File diff suppressed because it is too large Load Diff

45
tests/monster_test_generated.h
View File

@@ -1202,6 +1202,7 @@ struct MonsterT : public flatbuffers::NativeTable {
MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous;
std::vector<MyGame::Example::Color> vector_of_enums;
MyGame::Example::Race signed_enum;
std::vector<uint8_t> testrequirednestedflatbuffer;
MonsterT()
: mana(150),
hp(100),
@@ -1271,7 +1272,8 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
(lhs.any_unique == rhs.any_unique) &&
(lhs.any_ambiguous == rhs.any_ambiguous) &&
(lhs.vector_of_enums == rhs.vector_of_enums) &&
(lhs.signed_enum == rhs.signed_enum);
(lhs.signed_enum == rhs.signed_enum) &&
(lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer);
}
inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -1334,7 +1336,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_ANY_AMBIGUOUS_TYPE = 94,
VT_ANY_AMBIGUOUS = 96,
VT_VECTOR_OF_ENUMS = 98,
VT_SIGNED_ENUM = 100
VT_SIGNED_ENUM = 100,
VT_TESTREQUIREDNESTEDFLATBUFFER = 102
};
const MyGame::Example::Vec3 *pos() const {
return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1658,6 +1661,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_signed_enum(MyGame::Example::Race _signed_enum) {
return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
}
const flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
}
flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
}
const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1738,6 +1750,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
verifier.VerifyVector(vector_of_enums()) &&
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1917,6 +1931,9 @@ struct MonsterBuilder {
void add_signed_enum(MyGame::Example::Race signed_enum) {
fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
}
void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1978,7 +1995,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
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) {
MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
MonsterBuilder builder_(_fbb);
builder_.add_non_owning_reference(non_owning_reference);
builder_.add_co_owning_reference(co_owning_reference);
@@ -1987,6 +2005,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_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
builder_.add_vector_of_enums(vector_of_enums);
builder_.add_any_ambiguous(any_ambiguous);
builder_.add_any_unique(any_unique);
@@ -2080,7 +2099,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
flatbuffers::Offset<void> any_ambiguous = 0,
const std::vector<uint8_t> *vector_of_enums = nullptr,
MyGame::Example::Race signed_enum = MyGame::Example::Race_None) {
MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
const std::vector<uint8_t> *testrequirednestedflatbuffer = 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;
@@ -2100,6 +2120,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
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;
return MyGame::Example::CreateMonster(
_fbb,
pos,
@@ -2149,7 +2170,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
any_ambiguous_type,
any_ambiguous,
vector_of_enums__,
signed_enum);
signed_enum,
testrequirednestedflatbuffer__);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2635,6 +2657,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
{ auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
{ 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()); } }
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2693,6 +2716,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
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;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -2742,7 +2766,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_any_ambiguous_type,
_any_ambiguous,
_vector_of_enums,
_signed_enum);
_signed_enum,
_testrequirednestedflatbuffer);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3429,7 +3454,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_UTYPE, 0, 10 },
{ flatbuffers::ET_SEQUENCE, 0, 10 },
{ flatbuffers::ET_UCHAR, 1, 1 },
{ flatbuffers::ET_CHAR, 0, 11 }
{ flatbuffers::ET_CHAR, 0, 11 },
{ flatbuffers::ET_UCHAR, 1, -1 }
};
static const flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::Vec3TypeTable,
@@ -3494,10 +3520,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"any_ambiguous_type",
"any_ambiguous",
"vector_of_enums",
"signed_enum"
"signed_enum",
"testrequirednestedflatbuffer"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 49, type_codes, type_refs, nullptr, nullptr, names
flatbuffers::ST_TABLE, 50, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

56
tests/monster_test_generated.js
View File

@@ -1904,11 +1904,36 @@ MyGame.Example.Monster.prototype.mutate_signed_enum = function(value) {
return true;
};
/**
* @param {number} index
* @returns {number}
*/
MyGame.Example.Monster.prototype.testrequirednestedflatbuffer = function(index) {
var offset = this.bb.__offset(this.bb_pos, 102);
return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};
/**
* @returns {number}
*/
MyGame.Example.Monster.prototype.testrequirednestedflatbufferLength = function() {
var offset = this.bb.__offset(this.bb_pos, 102);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};
/**
* @returns {Uint8Array}
*/
MyGame.Example.Monster.prototype.testrequirednestedflatbufferArray = function() {
var offset = this.bb.__offset(this.bb_pos, 102);
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 {flatbuffers.Builder} builder
*/
MyGame.Example.Monster.startMonster = function(builder) {
builder.startObject(49);
builder.startObject(50);
};
/**
@@ -2634,6 +2659,35 @@ MyGame.Example.Monster.addSignedEnum = function(builder, signedEnum) {
builder.addFieldInt8(48, signedEnum, MyGame.Example.Race.None);
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Offset} testrequirednestedflatbufferOffset
*/
MyGame.Example.Monster.addTestrequirednestedflatbuffer = function(builder, testrequirednestedflatbufferOffset) {
builder.addFieldOffset(49, testrequirednestedflatbufferOffset, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {Array.<number>} data
* @returns {flatbuffers.Offset}
*/
MyGame.Example.Monster.createTestrequirednestedflatbufferVector = function(builder, data) {
builder.startVector(1, data.length, 1);
for (var i = data.length - 1; i >= 0; i--) {
builder.addInt8(data[i]);
}
return builder.endVector();
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} numElems
*/
MyGame.Example.Monster.startTestrequirednestedflatbufferVector = function(builder, numElems) {
builder.startVector(1, numElems, 1);
};
/**
* @param {flatbuffers.Builder} builder
* @returns {flatbuffers.Offset}

16
tests/monster_test_generated.lobster
View File

@@ -360,13 +360,17 @@ class Monster : flatbuffers_handle
return buf_.flatbuffers_field_vector_len(pos_, 98)
def signed_enum():
return Race(buf_.flatbuffers_field_int8(pos_, 100, -1))
def testrequirednestedflatbuffer(i:int):
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 GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
struct MonsterBuilder:
b_:flatbuffers_builder
def start():
b_.StartObject(49)
b_.StartObject(50)
return this
def add_pos(pos:flatbuffers_offset):
b_.PrependStructSlot(0, pos)
@@ -512,6 +516,9 @@ struct MonsterBuilder:
def add_signed_enum(signed_enum:Race):
b_.PrependInt8Slot(48, signed_enum, -1)
return this
def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers_offset):
b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer)
return this
def end():
return b_.EndObject()
@@ -629,6 +636,13 @@ def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[Color]):
reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length)
def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers_builder, n_:int):
b_.StartVector(1, n_, 1)
def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers_builder, v_:[int]):
b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length)
class TypeAliases : flatbuffers_handle
def i8():
return buf_.flatbuffers_field_int8(pos_, 4, 0)

19
tests/monster_test_generated.rs
View File

@@ -1143,6 +1143,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.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); }
if let Some(x) = args.any_unique { builder.add_any_unique(x); }
@@ -1235,6 +1236,7 @@ impl<'a> Monster<'a> {
pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
#[inline]
pub fn pos(&self) -> Option<&'a Vec3> {
@@ -1447,6 +1449,16 @@ impl<'a> Monster<'a> {
self._tab.get::<Race>(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()
}
#[inline]
pub fn testrequirednestedflatbuffer(&self) -> Option<&'a [u8]> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None).map(|v| v.safe_slice())
}
pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>> {
self.testrequirednestedflatbuffer().map(|data| {
use flatbuffers::Follow;
<flatbuffers::ForwardsUOffset<Monster<'a>>>::follow(data, 0)
})
}
#[inline]
#[allow(non_snake_case)]
pub fn test_as_monster(&self) -> Option<Monster<'a>> {
if self.test_type() == Any::Monster {
@@ -1587,6 +1599,7 @@ pub struct MonsterArgs<'a> {
pub any_ambiguous: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Color>>>,
pub signed_enum: Race,
pub testrequirednestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for MonsterArgs<'a> {
#[inline]
@@ -1640,6 +1653,7 @@ impl<'a> Default for MonsterArgs<'a> {
any_ambiguous: None,
vector_of_enums: None,
signed_enum: Race::None,
testrequirednestedflatbuffer: None,
}
}
}
@@ -1841,6 +1855,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
self.fbb_.push_slot::<Race>(Monster::VT_SIGNED_ENUM, signed_enum, Race::None);
}
#[inline]
pub fn add_testrequirednestedflatbuffer(&mut self, testrequirednestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
let start = _fbb.start_table();
MonsterBuilder {
@@ -1985,6 +2003,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.finish()
}
}

66
tests/monster_test_generated.ts
View File

@@ -2200,11 +2200,36 @@ mutate_signed_enum(value:MyGame.Example.Race):boolean {
return true;
};
/**
* @param number index
* @returns number
*/
testrequirednestedflatbuffer(index: number):number|null {
var offset = this.bb!.__offset(this.bb_pos, 102);
return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
};
/**
* @returns number
*/
testrequirednestedflatbufferLength():number {
var offset = this.bb!.__offset(this.bb_pos, 102);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
};
/**
* @returns Uint8Array
*/
testrequirednestedflatbufferArray():Uint8Array|null {
var offset = this.bb!.__offset(this.bb_pos, 102);
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 flatbuffers.Builder builder
*/
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(49);
builder.startObject(50);
};
/**
@@ -2935,6 +2960,35 @@ static addSignedEnum(builder:flatbuffers.Builder, signedEnum:MyGame.Example.Race
builder.addFieldInt8(48, signedEnum, MyGame.Example.Race.None);
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset testrequirednestedflatbufferOffset
*/
static addTestrequirednestedflatbuffer(builder:flatbuffers.Builder, testrequirednestedflatbufferOffset:flatbuffers.Offset) {
builder.addFieldOffset(49, testrequirednestedflatbufferOffset, 0);
};
/**
* @param flatbuffers.Builder builder
* @param Array.<number> data
* @returns flatbuffers.Offset
*/
static createTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset {
builder.startVector(1, data.length, 1);
for (var i = data.length - 1; i >= 0; i--) {
builder.addInt8(data[i]);
}
return builder.endVector();
};
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(1, numElems, 1);
};
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
@@ -3034,7 +3088,8 @@ unpack(): MonsterT {
return temp.unpack()
})(),
this.bb!.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()),
this.signedEnum()
this.signedEnum(),
this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength())
);
};
@@ -3102,6 +3157,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());
};
}
@@ -3156,6 +3212,7 @@ export class MonsterT {
* @param MyGame.Example.MonsterT|null anyAmbiguous
* @param (MyGame.Example.Color)[] vectorOfEnums
* @param MyGame.Example.Race signedEnum
* @param (number)[] testrequirednestedflatbuffer
*/
constructor(
public pos: MyGame.Example.Vec3T|null = null,
@@ -3205,7 +3262,8 @@ constructor(
public anyAmbiguousType: MyGame.Example.AnyAmbiguousAliases = MyGame.Example.AnyAmbiguousAliases.NONE,
public anyAmbiguous: MyGame.Example.MonsterT|null = null,
public vectorOfEnums: (MyGame.Example.Color)[] = [],
public signedEnum: MyGame.Example.Race = MyGame.Example.Race.None
public signedEnum: MyGame.Example.Race = MyGame.Example.Race.None,
public testrequirednestedflatbuffer: (number)[] = []
){};
/**
@@ -3235,6 +3293,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const anyUnique = builder.createObjectOffset(this.anyUnique);
const anyAmbiguous = builder.createObjectOffset(this.anyAmbiguous);
const vectorOfEnums = MyGame.Example.Monster.createVectorOfEnumsVector(builder, this.vectorOfEnums);
const testrequirednestedflatbuffer = MyGame.Example.Monster.createTestrequirednestedflatbufferVector(builder, this.testrequirednestedflatbuffer);
MyGame.Example.Monster.start(builder);
MyGame.Example.Monster.addPos(builder, (this.pos !== null ? this.pos!.pack(builder) : 0));
@@ -3285,6 +3344,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
MyGame.Example.Monster.addAnyAmbiguous(builder, anyAmbiguous);
MyGame.Example.Monster.addVectorOfEnums(builder, vectorOfEnums);
MyGame.Example.Monster.addSignedEnum(builder, this.signedEnum);
MyGame.Example.Monster.addTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer);
return MyGame.Example.Monster.end(builder);
};

18
tests/monster_test_my_game.example_generated.dart
View File

@@ -801,10 +801,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);
@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}';
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}';
}
}
@@ -1019,6 +1020,10 @@ class MonsterBuilder {
fbBuilder.addInt8(48, signedEnum?.value);
return fbBuilder.offset;
}
int addTestrequirednestedflatbufferOffset(int offset) {
fbBuilder.addOffset(49, offset);
return fbBuilder.offset;
}
int finish() {
return fbBuilder.endTable();
@@ -1074,6 +1079,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final dynamic _anyAmbiguous;
final List<Color> _vectorOfEnums;
final Race _signedEnum;
final List<int> _testrequirednestedflatbuffer;
MonsterObjectBuilder({
Vec3ObjectBuilder pos,
@@ -1124,6 +1130,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
dynamic anyAmbiguous,
List<Color> vectorOfEnums,
Race signedEnum,
List<int> testrequirednestedflatbuffer,
})
: _pos = pos,
_mana = mana,
@@ -1172,7 +1179,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
_anyAmbiguousType = anyAmbiguousType,
_anyAmbiguous = anyAmbiguous,
_vectorOfEnums = vectorOfEnums,
_signedEnum = signedEnum;
_signedEnum = signedEnum,
_testrequirednestedflatbuffer = testrequirednestedflatbuffer;
/// Finish building, and store into the [fbBuilder].
@override
@@ -1240,6 +1248,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
final int vectorOfEnumsOffset = _vectorOfEnums?.isNotEmpty == true
? fbBuilder.writeListUint8(_vectorOfEnums.map((f) => f.value))
: null;
final int testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer?.isNotEmpty == true
? fbBuilder.writeListUint8(_testrequirednestedflatbuffer)
: null;
fbBuilder.startTable();
if (_pos != null) {
@@ -1342,6 +1353,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
fbBuilder.addOffset(47, vectorOfEnumsOffset);
}
fbBuilder.addInt8(48, _signedEnum?.value);
if (testrequirednestedflatbufferOffset != null) {
fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
}
return fbBuilder.endTable();
}

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

@@ -1561,7 +1561,8 @@ mod write_and_read_examples {
vector_of_co_owning_references: None, non_owning_reference: 0, \
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 }, test4: Some([Test { \
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None }, test4: Some([Test { \
a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
testarrayofstring: Some([\"test1\", \"test2\"]), \
testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
@@ -1578,7 +1579,8 @@ mod write_and_read_examples {
vector_of_co_owning_references: None, non_owning_reference: 0, \
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 }"
vector_of_enums: None, signed_enum: None, \
testrequirednestedflatbuffer: None }"
);
}