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

Lobster namespace change

Browse Source
This commit is contained in:
Wouter van Oortmerssen
2023-09-16 19:39:38 -07:00
parent 0343396e49
commit d3e8cb60a1
5 changed files with 339 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/idl_gen_lobster.cpp
View File

@@ -31,7 +31,7 @@ class LobsterGenerator : public BaseGenerator {
public: public:
LobsterGenerator(const Parser &parser, const std::string &path, LobsterGenerator(const Parser &parser, const std::string &path,
const std::string &file_name) const std::string &file_name)
: BaseGenerator(parser, path, file_name, "" /* not used */, "_", : BaseGenerator(parser, path, file_name, "" /* not used */, ".",
"lobster") { "lobster") {
static const char *const keywords[] = { static const char *const keywords[] = {
"nil", "true", "false", "return", "struct", "class", "nil", "true", "false", "return", "struct", "class",
@@ -79,7 +79,7 @@ class LobsterGenerator : public BaseGenerator {
if (IsBool(type.base_type)) return "bool"; if (IsBool(type.base_type)) return "bool";
if (IsScalar(type.base_type) && type.enum_def) if (IsScalar(type.base_type) && type.enum_def)
return NormalizedName(*type.enum_def); return NormalizedName(*type.enum_def);
if (!IsScalar(type.base_type)) return "flatbuffers_offset"; if (!IsScalar(type.base_type)) return "flatbuffers.offset";
if (IsString(type)) return "string"; if (IsString(type)) return "string";
return "int"; return "int";
} }
@@ -119,15 +119,17 @@ class LobsterGenerator : public BaseGenerator {
offsets + ")"; offsets + ")";
} else { } else {
auto defval = field.IsOptional() ? "0" : field.value.constant; auto defval = field.IsOptional()
acc = "buf_.flatbuffers_field_" + GenTypeName(field.value.type) + ? (IsFloat(field.value.type.base_type) ? "0.0" : "0")
"(pos_, " + offsets + ", " + defval + ")"; : field.value.constant;
acc = "flatbuffers.field_" + GenTypeName(field.value.type) +
"(buf_, pos_, " + offsets + ", " + defval + ")";
if (IsBool(field.value.type.base_type)) acc = "bool(" + acc + ")"; if (IsBool(field.value.type.base_type)) acc = "bool(" + acc + ")";
} }
if (field.value.type.enum_def) if (field.value.type.enum_def)
acc = NormalizedName(*field.value.type.enum_def) + "(" + acc + ")"; acc = NormalizedName(*field.value.type.enum_def) + "(" + acc + ")";
if (field.IsOptional()) { if (field.IsOptional()) {
acc += ", buf_.flatbuffers_field_present(pos_, " + offsets + ")"; acc += ", flatbuffers.field_present(buf_, pos_, " + offsets + ")";
code += def + "() -> " + LobsterType(field.value.type) + code += def + "() -> " + LobsterType(field.value.type) +
", bool:\n return " + acc + "\n"; ", bool:\n return " + acc + "\n";
} else { } else {
@@ -144,9 +146,9 @@ class LobsterGenerator : public BaseGenerator {
code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n"; code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n";
} else { } else {
code += def + "() -> " + name + "?:\n "; code += def + "() -> " + name + "?:\n ";
code += std::string("let o = buf_.flatbuffers_field_") + code += std::string("let o = flatbuffers.field_") +
(field.value.type.struct_def->fixed ? "struct" : "table") + (field.value.type.struct_def->fixed ? "struct" : "table") +
"(pos_, " + offsets + ")\n return if o: " + name + "(buf_, pos_, " + offsets + ")\n return if o: " + name +
" { buf_, o } else: nil\n"; " { buf_, o } else: nil\n";
} }
break; break;
@@ -154,16 +156,16 @@ class LobsterGenerator : public BaseGenerator {
case BASE_TYPE_STRING: case BASE_TYPE_STRING:
code += def + code += def +
"() -> string:\n return " "() -> string:\n return "
"buf_.flatbuffers_field_string(pos_, " + "flatbuffers.field_string(buf_, pos_, " +
offsets + ")\n"; offsets + ")\n";
break; break;
case BASE_TYPE_VECTOR: { case BASE_TYPE_VECTOR: {
auto vectortype = field.value.type.VectorType(); auto vectortype = field.value.type.VectorType();
if (vectortype.base_type == BASE_TYPE_STRUCT) { if (vectortype.base_type == BASE_TYPE_STRUCT) {
auto start = "buf_.flatbuffers_field_vector(pos_, " + offsets + auto start = "flatbuffers.field_vector(buf_, pos_, " + offsets +
") + i * " + NumToString(InlineSize(vectortype)); ") + i * " + NumToString(InlineSize(vectortype));
if (!(vectortype.struct_def->fixed)) { if (!(vectortype.struct_def->fixed)) {
start = "buf_.flatbuffers_indirect(" + start + ")"; start = "flatbuffers.indirect(buf_, " + start + ")";
} }
code += def + "(i:int) -> " + code += def + "(i:int) -> " +
NamespacedName(*field.value.type.struct_def) + NamespacedName(*field.value.type.struct_def) +
@@ -173,13 +175,13 @@ class LobsterGenerator : public BaseGenerator {
} else { } else {
if (IsString(vectortype)) { if (IsString(vectortype)) {
code += def + "(i:int) -> string:\n return "; code += def + "(i:int) -> string:\n return ";
code += "buf_.flatbuffers_string"; code += "flatbuffers.string";
} else { } else {
code += def + "(i:int) -> " + LobsterType(vectortype) + code += def + "(i:int) -> " + LobsterType(vectortype) +
":\n return "; ":\n return ";
code += "buf_.read_" + GenTypeName(vectortype) + "_le"; code += "read_" + GenTypeName(vectortype) + "_le";
} }
code += "(buf_.flatbuffers_field_vector(pos_, " + offsets + code += "(buf_, buf_.flatbuffers.field_vector(pos_, " + offsets +
") + i * " + NumToString(InlineSize(vectortype)) + ")\n"; ") + i * " + NumToString(InlineSize(vectortype)) + ")\n";
} }
break; break;
@@ -191,7 +193,7 @@ class LobsterGenerator : public BaseGenerator {
if (ev.IsNonZero()) { if (ev.IsNonZero()) {
code += def + "_as_" + ev.name + "():\n return " + code += def + "_as_" + ev.name + "():\n return " +
NamespacedName(*ev.union_type.struct_def) + NamespacedName(*ev.union_type.struct_def) +
" { buf_, buf_.flatbuffers_field_table(pos_, " + offsets + " { buf_, flatbuffers.field_table(buf_, pos_, " + offsets +
") }\n"; ") }\n";
} }
} }
@@ -202,7 +204,7 @@ class LobsterGenerator : public BaseGenerator {
if (IsVector(field.value.type)) { if (IsVector(field.value.type)) {
code += def + code += def +
"_length() -> int:\n return " "_length() -> int:\n return "
"buf_.flatbuffers_field_vector_len(pos_, " + "flatbuffers.field_vector_len(buf_, pos_, " +
offsets + ")\n"; offsets + ")\n";
} }
} }
@@ -211,7 +213,7 @@ class LobsterGenerator : public BaseGenerator {
void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) { void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "struct " + NormalizedName(struct_def) + code += "struct " + NormalizedName(struct_def) +
"Builder:\n b_:flatbuffers_builder\n"; "Builder:\n b_:flatbuffers.builder\n";
code += " def start():\n b_.StartObject(" + code += " def start():\n b_.StartObject(" +
NumToString(struct_def.fields.vec.size()) + NumToString(struct_def.fields.vec.size()) +
")\n return this\n"; ")\n return this\n";
@@ -236,7 +238,7 @@ class LobsterGenerator : public BaseGenerator {
if (IsVector(field.value.type)) { if (IsVector(field.value.type)) {
code += "def " + NormalizedName(struct_def) + "Start" + code += "def " + NormalizedName(struct_def) + "Start" +
ConvertCase(NormalizedName(field), Case::kUpperCamel) + ConvertCase(NormalizedName(field), Case::kUpperCamel) +
"Vector(b_:flatbuffers_builder, n_:int):\n b_.StartVector("; "Vector(b_:flatbuffers.builder, n_:int):\n b_.StartVector(";
auto vector_type = field.value.type.VectorType(); auto vector_type = field.value.type.VectorType();
auto alignment = InlineAlignment(vector_type); auto alignment = InlineAlignment(vector_type);
auto elem_size = InlineSize(vector_type); auto elem_size = InlineSize(vector_type);
@@ -246,7 +248,7 @@ class LobsterGenerator : public BaseGenerator {
!vector_type.struct_def->fixed) { !vector_type.struct_def->fixed) {
code += "def " + NormalizedName(struct_def) + "Create" + code += "def " + NormalizedName(struct_def) + "Create" +
ConvertCase(NormalizedName(field), Case::kUpperCamel) + ConvertCase(NormalizedName(field), Case::kUpperCamel) +
"Vector(b_:flatbuffers_builder, v_:[" + "Vector(b_:flatbuffers.builder, v_:[" +
LobsterType(vector_type) + "]):\n b_.StartVector(" + LobsterType(vector_type) + "]):\n b_.StartVector(" +
NumToString(elem_size) + ", v_.length, " + NumToString(elem_size) + ", v_.length, " +
NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" + NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" +
@@ -271,7 +273,7 @@ class LobsterGenerator : public BaseGenerator {
std::string &code = *code_ptr; std::string &code = *code_ptr;
CheckNameSpace(struct_def, &code); CheckNameSpace(struct_def, &code);
GenComment(struct_def.doc_comment, code_ptr, nullptr, ""); GenComment(struct_def.doc_comment, code_ptr, nullptr, "");
code += "class " + NormalizedName(struct_def) + " : flatbuffers_handle\n"; code += "class " + NormalizedName(struct_def) + " : flatbuffers.handle\n";
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
auto &field = **it; auto &field = **it;
@@ -284,7 +286,7 @@ class LobsterGenerator : public BaseGenerator {
// the root type. // the root type.
code += "def GetRootAs" + NormalizedName(struct_def) + code += "def GetRootAs" + NormalizedName(struct_def) +
"(buf:string): return " + NormalizedName(struct_def) + "(buf:string): return " + NormalizedName(struct_def) +
" { buf, buf.flatbuffers_indirect(0) }\n\n"; " { buf, flatbuffers.indirect(buf, 0) }\n\n";
} }
if (struct_def.fixed) { if (struct_def.fixed) {
// create a struct constructor function // create a struct constructor function
@@ -360,7 +362,7 @@ class LobsterGenerator : public BaseGenerator {
void GenStructBuilder(const StructDef &struct_def, std::string *code_ptr) { void GenStructBuilder(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += code +=
"def Create" + NormalizedName(struct_def) + "(b_:flatbuffers_builder"; "def Create" + NormalizedName(struct_def) + "(b_:flatbuffers.builder";
StructBuilderArgs(struct_def, "", code_ptr); StructBuilderArgs(struct_def, "", code_ptr);
code += "):\n"; code += "):\n";
StructBuilderBody(struct_def, "", code_ptr); StructBuilderBody(struct_def, "", code_ptr);

3
tests/LobsterTest.bat Normal file
View File

@@ -0,0 +1,3 @@
..\Release\flatc.exe --lobster -I include_test monster_test.fbs
..\Release\flatc.exe --lobster -I include_test optional_scalars.fbs
..\..\lobster\bin\lobster.exe .\lobstertest.lobster

62
tests/lobstertest.lobster
View File

@@ -18,9 +18,9 @@ import optional_scalars_generated
def check_read_buffer(buf): def check_read_buffer(buf):
// Check that the given buffer is evaluated correctly as the example Monster. // Check that the given buffer is evaluated correctly as the example Monster.
assert flatbuffers_has_identifier(buf, "MONS") assert flatbuffers.has_identifier(buf, "MONS")
let monster = MyGame_Example_GetRootAsMonster(buf) let monster = MyGame.Example.GetRootAsMonster(buf)
assert monster.hp == 80 assert monster.hp == 80
assert monster.mana == 150 assert monster.mana == 150
@@ -39,7 +39,7 @@ def check_read_buffer(buf):
assert t.a == 5 assert t.a == 5
assert t.b == 6 assert t.b == 6
assert monster.test_type == MyGame_Example_Any_Monster assert monster.test_type == MyGame.Example.Any_Monster
assert monster.test_as_Monster.name == "Fred" assert monster.test_as_Monster.name == "Fred"
assert monster.inventory_length == 5 assert monster.inventory_length == 5
@@ -48,7 +48,7 @@ def check_read_buffer(buf):
for(5) i: for(5) i:
assert monster.vector_of_longs(i) == pow(10, i * 2) assert monster.vector_of_longs(i) == pow(10, i * 2)
assert equal([-1.7976931348623157e+308, 0, 1.7976931348623157e+308], assert equal([-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308],
(map(monster.vector_of_doubles_length) i: monster.vector_of_doubles(i))) (map(monster.vector_of_doubles_length) i: monster.vector_of_doubles(i)))
assert monster.test4_length == 2 assert monster.test4_length == 2
@@ -66,40 +66,40 @@ def check_read_buffer(buf):
def make_monster_from_generated_code(): def make_monster_from_generated_code():
// Use generated code to build the example Monster. // Use generated code to build the example Monster.
let b = flatbuffers_builder {} let b = flatbuffers.builder {}
let name = b.CreateString("MyMonster") let name = b.CreateString("MyMonster")
let fred = b.CreateString("Fred") let fred = b.CreateString("Fred")
let inv = b.MyGame_Example_MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ]) let inv = b.MyGame.Example.MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ])
let mon2 = MyGame_Example_MonsterBuilder { b } let mon2 = MyGame.Example.MonsterBuilder { b }
.start() .start()
.add_name(fred) .add_name(fred)
.end() .end()
b.MyGame_Example_MonsterStartTest4Vector(2) b.MyGame.Example.MonsterStartTest4Vector(2)
b.MyGame_Example_CreateTest(10, 20) b.MyGame.Example.CreateTest(10, 20)
b.MyGame_Example_CreateTest(30, 40) b.MyGame.Example.CreateTest(30, 40)
let test4 = b.EndVector(2) let test4 = b.EndVector(2)
let test_array_of_string = b.MyGame_Example_MonsterCreateTestarrayofstringVector( let test_array_of_string = b.MyGame.Example.MonsterCreateTestarrayofstringVector(
[ b.CreateString("test1"), b.CreateString("test2") ]) [ b.CreateString("test1"), b.CreateString("test2") ])
let vector_of_longs = b.MyGame_Example_MonsterCreateVectorOfLongsVector( let vector_of_longs = b.MyGame.Example.MonsterCreateVectorOfLongsVector(
[ 1, 100, 10000, 1000000, 100000000 ]) [ 1, 100, 10000, 1000000, 100000000 ])
let vector_of_doubles = b.MyGame_Example_MonsterCreateVectorOfDoublesVector( let vector_of_doubles = b.MyGame.Example.MonsterCreateVectorOfDoublesVector(
[ -1.7976931348623157e+308, 0, 1.7976931348623157e+308 ]) [ -1.7976931348623157e+308, 0.0, 1.7976931348623157e+308 ])
let mon = MyGame_Example_MonsterBuilder { b } let mon = MyGame.Example.MonsterBuilder { b }
.start() .start()
.add_pos(b.MyGame_Example_CreateVec3(1.0, 2.0, 3.0, 3.0, .add_pos(b.MyGame.Example.CreateVec3(1.0, 2.0, 3.0, 3.0,
MyGame_Example_Color_Green, 5, 6)) MyGame.Example.Color_Green, 5, 6))
.add_hp(80) .add_hp(80)
.add_name(name) .add_name(name)
.add_inventory(inv) .add_inventory(inv)
.add_test_type(MyGame_Example_Any_Monster) .add_test_type(MyGame.Example.Any_Monster)
.add_test(mon2) .add_test(mon2)
.add_test4(test4) .add_test4(test4)
.add_testarrayofstring(test_array_of_string) .add_testarrayofstring(test_array_of_string)
@@ -113,8 +113,8 @@ def make_monster_from_generated_code():
def test_optional_scalars(): def test_optional_scalars():
def build(add_fields): def build(add_fields):
let b = flatbuffers_builder {} let b = flatbuffers.builder {}
let ss = optional_scalars_ScalarStuffBuilder { b }.start() let ss = optional_scalars.ScalarStuffBuilder { b }.start()
if add_fields: if add_fields:
ss.add_just_i8(1) ss.add_just_i8(1)
ss.add_maybe_i8(1) ss.add_maybe_i8(1)
@@ -125,13 +125,13 @@ def test_optional_scalars():
ss.add_just_bool(true) ss.add_just_bool(true)
ss.add_maybe_bool(true) ss.add_maybe_bool(true)
ss.add_default_bool(true) ss.add_default_bool(true)
ss.add_just_enum(optional_scalars_OptionalByte_Two) ss.add_just_enum(optional_scalars.OptionalByte_Two)
ss.add_maybe_enum(optional_scalars_OptionalByte_Two) ss.add_maybe_enum(optional_scalars.OptionalByte_Two)
ss.add_default_enum(optional_scalars_OptionalByte_Two) ss.add_default_enum(optional_scalars.OptionalByte_Two)
b.Finish(ss.end(), "NULL") b.Finish(ss.end(), "NULL")
let buf = b.SizedCopy() let buf = b.SizedCopy()
assert flatbuffers_has_identifier(buf, "NULL") assert flatbuffers.has_identifier(buf, "NULL")
return optional_scalars_GetRootAsScalarStuff(buf) return optional_scalars.GetRootAsScalarStuff(buf)
var root = build(true) var root = build(true)
@@ -147,9 +147,9 @@ def test_optional_scalars():
var maybe_val_bool, maybe_present_bool = root.maybe_bool() var maybe_val_bool, maybe_present_bool = root.maybe_bool()
assert maybe_val_bool == true and maybe_present_bool == true assert maybe_val_bool == true and maybe_present_bool == true
assert root.just_enum() == optional_scalars_OptionalByte_Two and root.default_enum() == optional_scalars_OptionalByte_Two assert root.just_enum() == optional_scalars.OptionalByte_Two and root.default_enum() == optional_scalars.OptionalByte_Two
var maybe_val_enum, maybe_present_enum = root.maybe_enum() var maybe_val_enum, maybe_present_enum = root.maybe_enum()
assert maybe_val_enum == optional_scalars_OptionalByte_Two and maybe_present_enum == true assert maybe_val_enum == optional_scalars.OptionalByte_Two and maybe_present_enum == true
root = build(false) root = build(false)
@@ -165,9 +165,9 @@ def test_optional_scalars():
maybe_val_bool, maybe_present_bool = root.maybe_bool() maybe_val_bool, maybe_present_bool = root.maybe_bool()
assert maybe_val_bool == false and maybe_present_bool == false assert maybe_val_bool == false and maybe_present_bool == false
assert root.just_enum() == optional_scalars_OptionalByte_None and root.default_enum() == optional_scalars_OptionalByte_One assert root.just_enum() == optional_scalars.OptionalByte_None and root.default_enum() == optional_scalars.OptionalByte_One
maybe_val_enum, maybe_present_enum = root.maybe_enum() maybe_val_enum, maybe_present_enum = root.maybe_enum()
assert maybe_val_enum == optional_scalars_OptionalByte_None and maybe_present_enum == false assert maybe_val_enum == optional_scalars.OptionalByte_None and maybe_present_enum == false
// Verify that the canonical flatbuffer file (produced by the C++ implementation) // Verify that the canonical flatbuffer file (produced by the C++ implementation)
@@ -188,10 +188,10 @@ let schema = read_file("monster_test.fbs")
assert schema assert schema
let includedirs = [ "include_test" ] let includedirs = [ "include_test" ]
// Convert binary to JSON: // Convert binary to JSON:
let json, err1 = flatbuffers_binary_to_json(schema, fb1, includedirs) let json, err1 = flatbuffers.binary_to_json(schema, fb1, includedirs)
assert not err1 assert not err1
// Parse JSON back to binary: // Parse JSON back to binary:
let fb3, err2 = flatbuffers_json_to_binary(schema, json, includedirs) let fb3, err2 = flatbuffers.json_to_binary(schema, json, includedirs)
assert not err2 assert not err2
// Check the resulting binary again (full roundtrip test): // Check the resulting binary again (full roundtrip test):
check_read_buffer(fb3) check_read_buffer(fb3)

484
tests/monster_test_generated.lobster
View File

@@ -1,7 +1,7 @@
// automatically generated by the FlatBuffers compiler, do not modify // automatically generated by the FlatBuffers compiler, do not modify
import flatbuffers import flatbuffers
namespace MyGame_Example namespace MyGame.Example
/// Composite components of Monster color. /// Composite components of Monster color.
enum Color: enum Color:
@@ -45,11 +45,11 @@ namespace MyGame
class InParentNamespace class InParentNamespace
namespace MyGame_Example2 namespace MyGame.Example2
class Monster class Monster
namespace MyGame_Example namespace MyGame.Example
class Test class Test
@@ -73,55 +73,55 @@ class TypeAliases
namespace MyGame namespace MyGame
class InParentNamespace : flatbuffers_handle class InParentNamespace : flatbuffers.handle
def GetRootAsInParentNamespace(buf:string): return InParentNamespace { buf, buf.flatbuffers_indirect(0) } def GetRootAsInParentNamespace(buf:string): return InParentNamespace { buf, flatbuffers.indirect(buf, 0) }
struct InParentNamespaceBuilder: struct InParentNamespaceBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(0) b_.StartObject(0)
return this return this
def end(): def end():
return b_.EndObject() return b_.EndObject()
namespace MyGame_Example2 namespace MyGame.Example2
class Monster : flatbuffers_handle class Monster : flatbuffers.handle
def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) } def GetRootAsMonster(buf:string): return Monster { buf, flatbuffers.indirect(buf, 0) }
struct MonsterBuilder: struct MonsterBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(0) b_.StartObject(0)
return this return this
def end(): def end():
return b_.EndObject() return b_.EndObject()
namespace MyGame_Example namespace MyGame.Example
class Test : flatbuffers_handle class Test : flatbuffers.handle
def a() -> int: def a() -> int:
return buf_.read_int16_le(pos_ + 0) return buf_.read_int16_le(pos_ + 0)
def b() -> int: def b() -> int:
return buf_.read_int8_le(pos_ + 2) return buf_.read_int8_le(pos_ + 2)
def CreateTest(b_:flatbuffers_builder, a:int, b:int): def CreateTest(b_:flatbuffers.builder, a:int, b:int):
b_.Prep(2, 4) b_.Prep(2, 4)
b_.Pad(1) b_.Pad(1)
b_.PrependInt8(b) b_.PrependInt8(b)
b_.PrependInt16(a) b_.PrependInt16(a)
return b_.Offset() return b_.Offset()
class TestSimpleTableWithEnum : flatbuffers_handle class TestSimpleTableWithEnum : flatbuffers.handle
def color() -> Color: def color() -> Color:
return Color(buf_.flatbuffers_field_uint8(pos_, 4, 2)) return Color(flatbuffers.field_uint8(buf_, pos_, 4, 2))
def GetRootAsTestSimpleTableWithEnum(buf:string): return TestSimpleTableWithEnum { buf, buf.flatbuffers_indirect(0) } def GetRootAsTestSimpleTableWithEnum(buf:string): return TestSimpleTableWithEnum { buf, flatbuffers.indirect(buf, 0) }
struct TestSimpleTableWithEnumBuilder: struct TestSimpleTableWithEnumBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(1) b_.StartObject(1)
return this return this
@@ -131,7 +131,7 @@ struct TestSimpleTableWithEnumBuilder:
def end(): def end():
return b_.EndObject() return b_.EndObject()
class Vec3 : flatbuffers_handle class Vec3 : flatbuffers.handle
def x() -> float: def x() -> float:
return buf_.read_float32_le(pos_ + 0) return buf_.read_float32_le(pos_ + 0)
def y() -> float: def y() -> float:
@@ -142,10 +142,10 @@ class Vec3 : flatbuffers_handle
return buf_.read_float64_le(pos_ + 16) return buf_.read_float64_le(pos_ + 16)
def test2() -> Color: def test2() -> Color:
return Color(buf_.read_uint8_le(pos_ + 24)) return Color(buf_.read_uint8_le(pos_ + 24))
def test3() -> MyGame_Example_Test: def test3() -> MyGame.Example.Test:
return MyGame_Example_Test{ buf_, pos_ + 26 } return MyGame.Example.Test{ buf_, pos_ + 26 }
def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, test2:Color, test3_a:int, test3_b:int): def CreateVec3(b_:flatbuffers.builder, x:float, y:float, z:float, test1:float, test2:Color, test3_a:int, test3_b:int):
b_.Prep(8, 32) b_.Prep(8, 32)
b_.Pad(2) b_.Pad(2)
b_.Prep(2, 4) b_.Prep(2, 4)
@@ -161,27 +161,27 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, t
b_.PrependFloat32(x) b_.PrependFloat32(x)
return b_.Offset() return b_.Offset()
class Ability : flatbuffers_handle class Ability : flatbuffers.handle
def id() -> int: def id() -> int:
return buf_.read_uint32_le(pos_ + 0) return buf_.read_uint32_le(pos_ + 0)
def distance() -> int: def distance() -> int:
return buf_.read_uint32_le(pos_ + 4) return buf_.read_uint32_le(pos_ + 4)
def CreateAbility(b_:flatbuffers_builder, id:int, distance:int): def CreateAbility(b_:flatbuffers.builder, id:int, distance:int):
b_.Prep(4, 8) b_.Prep(4, 8)
b_.PrependUint32(distance) b_.PrependUint32(distance)
b_.PrependUint32(id) b_.PrependUint32(id)
return b_.Offset() return b_.Offset()
class StructOfStructs : flatbuffers_handle class StructOfStructs : flatbuffers.handle
def a() -> MyGame_Example_Ability: def a() -> MyGame.Example.Ability:
return MyGame_Example_Ability{ buf_, pos_ + 0 } return MyGame.Example.Ability{ buf_, pos_ + 0 }
def b() -> MyGame_Example_Test: def b() -> MyGame.Example.Test:
return MyGame_Example_Test{ buf_, pos_ + 8 } return MyGame.Example.Test{ buf_, pos_ + 8 }
def c() -> MyGame_Example_Ability: def c() -> MyGame.Example.Ability:
return MyGame_Example_Ability{ buf_, pos_ + 12 } return MyGame.Example.Ability{ buf_, pos_ + 12 }
def CreateStructOfStructs(b_:flatbuffers_builder, a_id:int, a_distance:int, b_a:int, b_b:int, c_id:int, c_distance:int): def CreateStructOfStructs(b_:flatbuffers.builder, a_id:int, a_distance:int, b_a:int, b_b:int, c_id:int, c_distance:int):
b_.Prep(4, 20) b_.Prep(4, 20)
b_.Prep(4, 8) b_.Prep(4, 8)
b_.PrependUint32(c_distance) b_.PrependUint32(c_distance)
@@ -195,11 +195,11 @@ def CreateStructOfStructs(b_:flatbuffers_builder, a_id:int, a_distance:int, b_a:
b_.PrependUint32(a_id) b_.PrependUint32(a_id)
return b_.Offset() return b_.Offset()
class StructOfStructsOfStructs : flatbuffers_handle class StructOfStructsOfStructs : flatbuffers.handle
def a() -> MyGame_Example_StructOfStructs: def a() -> MyGame.Example.StructOfStructs:
return MyGame_Example_StructOfStructs{ buf_, pos_ + 0 } return MyGame.Example.StructOfStructs{ buf_, pos_ + 0 }
def CreateStructOfStructsOfStructs(b_:flatbuffers_builder, a_a_id:int, a_a_distance:int, a_b_a:int, a_b_b:int, a_c_id:int, a_c_distance:int): def CreateStructOfStructsOfStructs(b_:flatbuffers.builder, a_a_id:int, a_a_distance:int, a_b_a:int, a_b_b:int, a_c_id:int, a_c_distance:int):
b_.Prep(4, 20) b_.Prep(4, 20)
b_.Prep(4, 20) b_.Prep(4, 20)
b_.Prep(4, 8) b_.Prep(4, 8)
@@ -214,22 +214,22 @@ def CreateStructOfStructsOfStructs(b_:flatbuffers_builder, a_a_id:int, a_a_dista
b_.PrependUint32(a_a_id) b_.PrependUint32(a_a_id)
return b_.Offset() return b_.Offset()
class Stat : flatbuffers_handle class Stat : flatbuffers.handle
def id() -> string: def id() -> string:
return buf_.flatbuffers_field_string(pos_, 4) return flatbuffers.field_string(buf_, pos_, 4)
def val() -> int: def val() -> int:
return buf_.flatbuffers_field_int64(pos_, 6, 0) return flatbuffers.field_int64(buf_, pos_, 6, 0)
def count() -> int: def count() -> int:
return buf_.flatbuffers_field_uint16(pos_, 8, 0) return flatbuffers.field_uint16(buf_, pos_, 8, 0)
def GetRootAsStat(buf:string): return Stat { buf, buf.flatbuffers_indirect(0) } def GetRootAsStat(buf:string): return Stat { buf, flatbuffers.indirect(buf, 0) }
struct StatBuilder: struct StatBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(3) b_.StartObject(3)
return this return this
def add_id(id:flatbuffers_offset): def add_id(id:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(0, id) b_.PrependUOffsetTRelativeSlot(0, id)
return this return this
def add_val(val:int): def add_val(val:int):
@@ -241,14 +241,14 @@ struct StatBuilder:
def end(): def end():
return b_.EndObject() return b_.EndObject()
class Referrable : flatbuffers_handle class Referrable : flatbuffers.handle
def id() -> int: def id() -> int:
return buf_.flatbuffers_field_uint64(pos_, 4, 0) return flatbuffers.field_uint64(buf_, pos_, 4, 0)
def GetRootAsReferrable(buf:string): return Referrable { buf, buf.flatbuffers_indirect(0) } def GetRootAsReferrable(buf:string): return Referrable { buf, flatbuffers.indirect(buf, 0) }
struct ReferrableBuilder: struct ReferrableBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(1) b_.StartObject(1)
return this return this
@@ -259,197 +259,197 @@ struct ReferrableBuilder:
return b_.EndObject() return b_.EndObject()
/// an example documentation comment: "monster object" /// an example documentation comment: "monster object"
class Monster : flatbuffers_handle class Monster : flatbuffers.handle
def pos() -> MyGame_Example_Vec3?: def pos() -> MyGame.Example.Vec3?:
let o = buf_.flatbuffers_field_struct(pos_, 4) let o = flatbuffers.field_struct(buf_, pos_, 4)
return if o: MyGame_Example_Vec3 { buf_, o } else: nil return if o: MyGame.Example.Vec3 { buf_, o } else: nil
def mana() -> int: def mana() -> int:
return buf_.flatbuffers_field_int16(pos_, 6, 150) return flatbuffers.field_int16(buf_, pos_, 6, 150)
def hp() -> int: def hp() -> int:
return buf_.flatbuffers_field_int16(pos_, 8, 100) return flatbuffers.field_int16(buf_, pos_, 8, 100)
def name() -> string: def name() -> string:
return buf_.flatbuffers_field_string(pos_, 10) return flatbuffers.field_string(buf_, pos_, 10)
def inventory(i:int) -> int: def inventory(i:int) -> int:
return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1) return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 14) + i * 1)
def inventory_length() -> int: def inventory_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 14) return flatbuffers.field_vector_len(buf_, pos_, 14)
def color() -> Color: def color() -> Color:
return Color(buf_.flatbuffers_field_uint8(pos_, 16, 8)) return Color(flatbuffers.field_uint8(buf_, pos_, 16, 8))
def test_type() -> Any: def test_type() -> Any:
return Any(buf_.flatbuffers_field_uint8(pos_, 18, 0)) return Any(flatbuffers.field_uint8(buf_, pos_, 18, 0))
def test_as_Monster(): def test_as_Monster():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 20) }
def test_as_TestSimpleTableWithEnum(): def test_as_TestSimpleTableWithEnum():
return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 20) } return MyGame.Example.TestSimpleTableWithEnum { buf_, flatbuffers.field_table(buf_, pos_, 20) }
def test_as_MyGame_Example2_Monster(): def test_as_MyGame_Example2_Monster():
return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } return MyGame.Example2.Monster { buf_, flatbuffers.field_table(buf_, pos_, 20) }
def test4(i:int) -> MyGame_Example_Test: def test4(i:int) -> MyGame.Example.Test:
return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 } return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 22) + i * 4 }
def test4_length() -> int: def test4_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 22) return flatbuffers.field_vector_len(buf_, pos_, 22)
def testarrayofstring(i:int) -> string: def testarrayofstring(i:int) -> string:
return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 24) + i * 4) return flatbuffers.string(buf_, buf_.flatbuffers.field_vector(pos_, 24) + i * 4)
def testarrayofstring_length() -> int: def testarrayofstring_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 24) return flatbuffers.field_vector_len(buf_, pos_, 24)
/// an example documentation comment: this will end up in the generated code /// an example documentation comment: this will end up in the generated code
/// multiline too /// multiline too
def testarrayoftables(i:int) -> MyGame_Example_Monster: def testarrayoftables(i:int) -> MyGame.Example.Monster:
return MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) } return MyGame.Example.Monster { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 26) + i * 4) }
def testarrayoftables_length() -> int: def testarrayoftables_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 26) return flatbuffers.field_vector_len(buf_, pos_, 26)
def enemy() -> MyGame_Example_Monster?: def enemy() -> MyGame.Example.Monster?:
let o = buf_.flatbuffers_field_table(pos_, 28) let o = flatbuffers.field_table(buf_, pos_, 28)
return if o: MyGame_Example_Monster { buf_, o } else: nil return if o: MyGame.Example.Monster { buf_, o } else: nil
def testnestedflatbuffer(i:int) -> int: def testnestedflatbuffer(i:int) -> int:
return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 30) + i * 1) return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 30) + i * 1)
def testnestedflatbuffer_length() -> int: def testnestedflatbuffer_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 30) return flatbuffers.field_vector_len(buf_, pos_, 30)
def testempty() -> MyGame_Example_Stat?: def testempty() -> MyGame.Example.Stat?:
let o = buf_.flatbuffers_field_table(pos_, 32) let o = flatbuffers.field_table(buf_, pos_, 32)
return if o: MyGame_Example_Stat { buf_, o } else: nil return if o: MyGame.Example.Stat { buf_, o } else: nil
def testbool() -> bool: def testbool() -> bool:
return bool(buf_.flatbuffers_field_int8(pos_, 34, 0)) return bool(flatbuffers.field_int8(buf_, pos_, 34, 0))
def testhashs32_fnv1() -> int: def testhashs32_fnv1() -> int:
return buf_.flatbuffers_field_int32(pos_, 36, 0) return flatbuffers.field_int32(buf_, pos_, 36, 0)
def testhashu32_fnv1() -> int: def testhashu32_fnv1() -> int:
return buf_.flatbuffers_field_uint32(pos_, 38, 0) return flatbuffers.field_uint32(buf_, pos_, 38, 0)
def testhashs64_fnv1() -> int: def testhashs64_fnv1() -> int:
return buf_.flatbuffers_field_int64(pos_, 40, 0) return flatbuffers.field_int64(buf_, pos_, 40, 0)
def testhashu64_fnv1() -> int: def testhashu64_fnv1() -> int:
return buf_.flatbuffers_field_uint64(pos_, 42, 0) return flatbuffers.field_uint64(buf_, pos_, 42, 0)
def testhashs32_fnv1a() -> int: def testhashs32_fnv1a() -> int:
return buf_.flatbuffers_field_int32(pos_, 44, 0) return flatbuffers.field_int32(buf_, pos_, 44, 0)
def testhashu32_fnv1a() -> int: def testhashu32_fnv1a() -> int:
return buf_.flatbuffers_field_uint32(pos_, 46, 0) return flatbuffers.field_uint32(buf_, pos_, 46, 0)
def testhashs64_fnv1a() -> int: def testhashs64_fnv1a() -> int:
return buf_.flatbuffers_field_int64(pos_, 48, 0) return flatbuffers.field_int64(buf_, pos_, 48, 0)
def testhashu64_fnv1a() -> int: def testhashu64_fnv1a() -> int:
return buf_.flatbuffers_field_uint64(pos_, 50, 0) return flatbuffers.field_uint64(buf_, pos_, 50, 0)
def testarrayofbools(i:int) -> bool: def testarrayofbools(i:int) -> bool:
return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 52) + i * 1) return read_int8_le(buf_, buf_.flatbuffers.field_vector(pos_, 52) + i * 1)
def testarrayofbools_length() -> int: def testarrayofbools_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 52) return flatbuffers.field_vector_len(buf_, pos_, 52)
def testf() -> float: def testf() -> float:
return buf_.flatbuffers_field_float32(pos_, 54, 3.14159) return flatbuffers.field_float32(buf_, pos_, 54, 3.14159)
def testf2() -> float: def testf2() -> float:
return buf_.flatbuffers_field_float32(pos_, 56, 3.0) return flatbuffers.field_float32(buf_, pos_, 56, 3.0)
def testf3() -> float: def testf3() -> float:
return buf_.flatbuffers_field_float32(pos_, 58, 0.0) return flatbuffers.field_float32(buf_, pos_, 58, 0.0)
def testarrayofstring2(i:int) -> string: def testarrayofstring2(i:int) -> string:
return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 60) + i * 4) return flatbuffers.string(buf_, buf_.flatbuffers.field_vector(pos_, 60) + i * 4)
def testarrayofstring2_length() -> int: def testarrayofstring2_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 60) return flatbuffers.field_vector_len(buf_, pos_, 60)
def testarrayofsortedstruct(i:int) -> MyGame_Example_Ability: def testarrayofsortedstruct(i:int) -> MyGame.Example.Ability:
return MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 } return MyGame.Example.Ability { buf_, flatbuffers.field_vector(buf_, pos_, 62) + i * 8 }
def testarrayofsortedstruct_length() -> int: def testarrayofsortedstruct_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 62) return flatbuffers.field_vector_len(buf_, pos_, 62)
def flex(i:int) -> int: def flex(i:int) -> int:
return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 64) + i * 1) return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 64) + i * 1)
def flex_length() -> int: def flex_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 64) return flatbuffers.field_vector_len(buf_, pos_, 64)
def test5(i:int) -> MyGame_Example_Test: def test5(i:int) -> MyGame.Example.Test:
return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 } return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 66) + i * 4 }
def test5_length() -> int: def test5_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 66) return flatbuffers.field_vector_len(buf_, pos_, 66)
def vector_of_longs(i:int) -> int: def vector_of_longs(i:int) -> int:
return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 68) + i * 8) return read_int64_le(buf_, buf_.flatbuffers.field_vector(pos_, 68) + i * 8)
def vector_of_longs_length() -> int: def vector_of_longs_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 68) return flatbuffers.field_vector_len(buf_, pos_, 68)
def vector_of_doubles(i:int) -> float: def vector_of_doubles(i:int) -> float:
return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 70) + i * 8) return read_float64_le(buf_, buf_.flatbuffers.field_vector(pos_, 70) + i * 8)
def vector_of_doubles_length() -> int: def vector_of_doubles_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 70) return flatbuffers.field_vector_len(buf_, pos_, 70)
def parent_namespace_test() -> MyGame_InParentNamespace?: def parent_namespace_test() -> MyGame.InParentNamespace?:
let o = buf_.flatbuffers_field_table(pos_, 72) let o = flatbuffers.field_table(buf_, pos_, 72)
return if o: MyGame_InParentNamespace { buf_, o } else: nil return if o: MyGame.InParentNamespace { buf_, o } else: nil
def vector_of_referrables(i:int) -> MyGame_Example_Referrable: def vector_of_referrables(i:int) -> MyGame.Example.Referrable:
return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 74) + i * 4) } return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 74) + i * 4) }
def vector_of_referrables_length() -> int: def vector_of_referrables_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 74) return flatbuffers.field_vector_len(buf_, pos_, 74)
def single_weak_reference() -> int: def single_weak_reference() -> int:
return buf_.flatbuffers_field_uint64(pos_, 76, 0) return flatbuffers.field_uint64(buf_, pos_, 76, 0)
def vector_of_weak_references(i:int) -> int: def vector_of_weak_references(i:int) -> int:
return buf_.read_uint64_le(buf_.flatbuffers_field_vector(pos_, 78) + i * 8) return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 78) + i * 8)
def vector_of_weak_references_length() -> int: def vector_of_weak_references_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 78) return flatbuffers.field_vector_len(buf_, pos_, 78)
def vector_of_strong_referrables(i:int) -> MyGame_Example_Referrable: def vector_of_strong_referrables(i:int) -> MyGame.Example.Referrable:
return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 80) + i * 4) } return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 80) + i * 4) }
def vector_of_strong_referrables_length() -> int: def vector_of_strong_referrables_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 80) return flatbuffers.field_vector_len(buf_, pos_, 80)
def co_owning_reference() -> int: def co_owning_reference() -> int:
return buf_.flatbuffers_field_uint64(pos_, 82, 0) return flatbuffers.field_uint64(buf_, pos_, 82, 0)
def vector_of_co_owning_references(i:int) -> int: def vector_of_co_owning_references(i:int) -> int:
return buf_.read_uint64_le(buf_.flatbuffers_field_vector(pos_, 84) + i * 8) return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 84) + i * 8)
def vector_of_co_owning_references_length() -> int: def vector_of_co_owning_references_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 84) return flatbuffers.field_vector_len(buf_, pos_, 84)
def non_owning_reference() -> int: def non_owning_reference() -> int:
return buf_.flatbuffers_field_uint64(pos_, 86, 0) return flatbuffers.field_uint64(buf_, pos_, 86, 0)
def vector_of_non_owning_references(i:int) -> int: def vector_of_non_owning_references(i:int) -> int:
return buf_.read_uint64_le(buf_.flatbuffers_field_vector(pos_, 88) + i * 8) return read_uint64_le(buf_, buf_.flatbuffers.field_vector(pos_, 88) + i * 8)
def vector_of_non_owning_references_length() -> int: def vector_of_non_owning_references_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 88) return flatbuffers.field_vector_len(buf_, pos_, 88)
def any_unique_type() -> AnyUniqueAliases: def any_unique_type() -> AnyUniqueAliases:
return AnyUniqueAliases(buf_.flatbuffers_field_uint8(pos_, 90, 0)) return AnyUniqueAliases(flatbuffers.field_uint8(buf_, pos_, 90, 0))
def any_unique_as_M(): def any_unique_as_M():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 92) }
def any_unique_as_TS(): def any_unique_as_TS():
return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame.Example.TestSimpleTableWithEnum { buf_, flatbuffers.field_table(buf_, pos_, 92) }
def any_unique_as_M2(): def any_unique_as_M2():
return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame.Example2.Monster { buf_, flatbuffers.field_table(buf_, pos_, 92) }
def any_ambiguous_type() -> AnyAmbiguousAliases: def any_ambiguous_type() -> AnyAmbiguousAliases:
return AnyAmbiguousAliases(buf_.flatbuffers_field_uint8(pos_, 94, 0)) return AnyAmbiguousAliases(flatbuffers.field_uint8(buf_, pos_, 94, 0))
def any_ambiguous_as_M1(): def any_ambiguous_as_M1():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
def any_ambiguous_as_M2(): def any_ambiguous_as_M2():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
def any_ambiguous_as_M3(): def any_ambiguous_as_M3():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) } return MyGame.Example.Monster { buf_, flatbuffers.field_table(buf_, pos_, 96) }
def vector_of_enums(i:int) -> Color: def vector_of_enums(i:int) -> Color:
return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1) return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 98) + i * 1)
def vector_of_enums_length() -> int: def vector_of_enums_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 98) return flatbuffers.field_vector_len(buf_, pos_, 98)
def signed_enum() -> Race: def signed_enum() -> Race:
return Race(buf_.flatbuffers_field_int8(pos_, 100, -1)) return Race(flatbuffers.field_int8(buf_, pos_, 100, -1))
def testrequirednestedflatbuffer(i:int) -> int: def testrequirednestedflatbuffer(i:int) -> int:
return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 102) + i * 1) return read_uint8_le(buf_, buf_.flatbuffers.field_vector(pos_, 102) + i * 1)
def testrequirednestedflatbuffer_length() -> int: def testrequirednestedflatbuffer_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 102) return flatbuffers.field_vector_len(buf_, pos_, 102)
def scalar_key_sorted_tables(i:int) -> MyGame_Example_Stat: def scalar_key_sorted_tables(i:int) -> MyGame.Example.Stat:
return MyGame_Example_Stat { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 104) + i * 4) } return MyGame.Example.Stat { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 104) + i * 4) }
def scalar_key_sorted_tables_length() -> int: def scalar_key_sorted_tables_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 104) return flatbuffers.field_vector_len(buf_, pos_, 104)
def native_inline() -> MyGame_Example_Test?: def native_inline() -> MyGame.Example.Test?:
let o = buf_.flatbuffers_field_struct(pos_, 106) let o = flatbuffers.field_struct(buf_, pos_, 106)
return if o: MyGame_Example_Test { buf_, o } else: nil return if o: MyGame.Example.Test { buf_, o } else: nil
def long_enum_non_enum_default() -> LongEnum: def long_enum_non_enum_default() -> LongEnum:
return LongEnum(buf_.flatbuffers_field_uint64(pos_, 108, 0)) return LongEnum(flatbuffers.field_uint64(buf_, pos_, 108, 0))
def long_enum_normal_default() -> LongEnum: def long_enum_normal_default() -> LongEnum:
return LongEnum(buf_.flatbuffers_field_uint64(pos_, 110, 2)) return LongEnum(flatbuffers.field_uint64(buf_, pos_, 110, 2))
def nan_default() -> float: def nan_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 112, nan) return flatbuffers.field_float32(buf_, pos_, 112, nan)
def inf_default() -> float: def inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 114, inf) return flatbuffers.field_float32(buf_, pos_, 114, inf)
def positive_inf_default() -> float: def positive_inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 116, +inf) return flatbuffers.field_float32(buf_, pos_, 116, +inf)
def infinity_default() -> float: def infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 118, infinity) return flatbuffers.field_float32(buf_, pos_, 118, infinity)
def positive_infinity_default() -> float: def positive_infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 120, +infinity) return flatbuffers.field_float32(buf_, pos_, 120, +infinity)
def negative_inf_default() -> float: def negative_inf_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 122, -inf) return flatbuffers.field_float32(buf_, pos_, 122, -inf)
def negative_infinity_default() -> float: def negative_infinity_default() -> float:
return buf_.flatbuffers_field_float32(pos_, 124, -infinity) return flatbuffers.field_float32(buf_, pos_, 124, -infinity)
def double_inf_default() -> float: def double_inf_default() -> float:
return buf_.flatbuffers_field_float64(pos_, 126, inf) return flatbuffers.field_float64(buf_, pos_, 126, inf)
def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) } def GetRootAsMonster(buf:string): return Monster { buf, flatbuffers.indirect(buf, 0) }
struct MonsterBuilder: struct MonsterBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(62) b_.StartObject(62)
return this return this
def add_pos(pos:flatbuffers_offset): def add_pos(pos:flatbuffers.offset):
b_.PrependStructSlot(0, pos) b_.PrependStructSlot(0, pos)
return this return this
def add_mana(mana:int): def add_mana(mana:int):
@@ -458,10 +458,10 @@ struct MonsterBuilder:
def add_hp(hp:int): def add_hp(hp:int):
b_.PrependInt16Slot(2, hp, 100) b_.PrependInt16Slot(2, hp, 100)
return this return this
def add_name(name:flatbuffers_offset): def add_name(name:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(3, name) b_.PrependUOffsetTRelativeSlot(3, name)
return this return this
def add_inventory(inventory:flatbuffers_offset): def add_inventory(inventory:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(5, inventory) b_.PrependUOffsetTRelativeSlot(5, inventory)
return this return this
def add_color(color:Color): def add_color(color:Color):
@@ -470,25 +470,25 @@ struct MonsterBuilder:
def add_test_type(test_type:Any): def add_test_type(test_type:Any):
b_.PrependUint8Slot(7, test_type, 0) b_.PrependUint8Slot(7, test_type, 0)
return this return this
def add_test(test:flatbuffers_offset): def add_test(test:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(8, test) b_.PrependUOffsetTRelativeSlot(8, test)
return this return this
def add_test4(test4:flatbuffers_offset): def add_test4(test4:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(9, test4) b_.PrependUOffsetTRelativeSlot(9, test4)
return this return this
def add_testarrayofstring(testarrayofstring:flatbuffers_offset): def add_testarrayofstring(testarrayofstring:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(10, testarrayofstring) b_.PrependUOffsetTRelativeSlot(10, testarrayofstring)
return this return this
def add_testarrayoftables(testarrayoftables:flatbuffers_offset): def add_testarrayoftables(testarrayoftables:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(11, testarrayoftables) b_.PrependUOffsetTRelativeSlot(11, testarrayoftables)
return this return this
def add_enemy(enemy:flatbuffers_offset): def add_enemy(enemy:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(12, enemy) b_.PrependUOffsetTRelativeSlot(12, enemy)
return this return this
def add_testnestedflatbuffer(testnestedflatbuffer:flatbuffers_offset): def add_testnestedflatbuffer(testnestedflatbuffer:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(13, testnestedflatbuffer) b_.PrependUOffsetTRelativeSlot(13, testnestedflatbuffer)
return this return this
def add_testempty(testempty:flatbuffers_offset): def add_testempty(testempty:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(14, testempty) b_.PrependUOffsetTRelativeSlot(14, testempty)
return this return this
def add_testbool(testbool:bool): def add_testbool(testbool:bool):
@@ -518,7 +518,7 @@ struct MonsterBuilder:
def add_testhashu64_fnv1a(testhashu64_fnv1a:int): def add_testhashu64_fnv1a(testhashu64_fnv1a:int):
b_.PrependUint64Slot(23, testhashu64_fnv1a, 0) b_.PrependUint64Slot(23, testhashu64_fnv1a, 0)
return this return this
def add_testarrayofbools(testarrayofbools:flatbuffers_offset): def add_testarrayofbools(testarrayofbools:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(24, testarrayofbools) b_.PrependUOffsetTRelativeSlot(24, testarrayofbools)
return this return this
def add_testf(testf:float): def add_testf(testf:float):
@@ -530,76 +530,76 @@ struct MonsterBuilder:
def add_testf3(testf3:float): def add_testf3(testf3:float):
b_.PrependFloat32Slot(27, testf3, 0.0) b_.PrependFloat32Slot(27, testf3, 0.0)
return this return this
def add_testarrayofstring2(testarrayofstring2:flatbuffers_offset): def add_testarrayofstring2(testarrayofstring2:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(28, testarrayofstring2) b_.PrependUOffsetTRelativeSlot(28, testarrayofstring2)
return this return this
def add_testarrayofsortedstruct(testarrayofsortedstruct:flatbuffers_offset): def add_testarrayofsortedstruct(testarrayofsortedstruct:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct) b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct)
return this return this
def add_flex(flex:flatbuffers_offset): def add_flex(flex:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(30, flex) b_.PrependUOffsetTRelativeSlot(30, flex)
return this return this
def add_test5(test5:flatbuffers_offset): def add_test5(test5:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(31, test5) b_.PrependUOffsetTRelativeSlot(31, test5)
return this return this
def add_vector_of_longs(vector_of_longs:flatbuffers_offset): def add_vector_of_longs(vector_of_longs:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(32, vector_of_longs) b_.PrependUOffsetTRelativeSlot(32, vector_of_longs)
return this return this
def add_vector_of_doubles(vector_of_doubles:flatbuffers_offset): def add_vector_of_doubles(vector_of_doubles:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(33, vector_of_doubles) b_.PrependUOffsetTRelativeSlot(33, vector_of_doubles)
return this return this
def add_parent_namespace_test(parent_namespace_test:flatbuffers_offset): def add_parent_namespace_test(parent_namespace_test:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(34, parent_namespace_test) b_.PrependUOffsetTRelativeSlot(34, parent_namespace_test)
return this return this
def add_vector_of_referrables(vector_of_referrables:flatbuffers_offset): def add_vector_of_referrables(vector_of_referrables:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(35, vector_of_referrables) b_.PrependUOffsetTRelativeSlot(35, vector_of_referrables)
return this return this
def add_single_weak_reference(single_weak_reference:int): def add_single_weak_reference(single_weak_reference:int):
b_.PrependUint64Slot(36, single_weak_reference, 0) b_.PrependUint64Slot(36, single_weak_reference, 0)
return this return this
def add_vector_of_weak_references(vector_of_weak_references:flatbuffers_offset): def add_vector_of_weak_references(vector_of_weak_references:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(37, vector_of_weak_references) b_.PrependUOffsetTRelativeSlot(37, vector_of_weak_references)
return this return this
def add_vector_of_strong_referrables(vector_of_strong_referrables:flatbuffers_offset): def add_vector_of_strong_referrables(vector_of_strong_referrables:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(38, vector_of_strong_referrables) b_.PrependUOffsetTRelativeSlot(38, vector_of_strong_referrables)
return this return this
def add_co_owning_reference(co_owning_reference:int): def add_co_owning_reference(co_owning_reference:int):
b_.PrependUint64Slot(39, co_owning_reference, 0) b_.PrependUint64Slot(39, co_owning_reference, 0)
return this return this
def add_vector_of_co_owning_references(vector_of_co_owning_references:flatbuffers_offset): def add_vector_of_co_owning_references(vector_of_co_owning_references:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(40, vector_of_co_owning_references) b_.PrependUOffsetTRelativeSlot(40, vector_of_co_owning_references)
return this return this
def add_non_owning_reference(non_owning_reference:int): def add_non_owning_reference(non_owning_reference:int):
b_.PrependUint64Slot(41, non_owning_reference, 0) b_.PrependUint64Slot(41, non_owning_reference, 0)
return this return this
def add_vector_of_non_owning_references(vector_of_non_owning_references:flatbuffers_offset): def add_vector_of_non_owning_references(vector_of_non_owning_references:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(42, vector_of_non_owning_references) b_.PrependUOffsetTRelativeSlot(42, vector_of_non_owning_references)
return this return this
def add_any_unique_type(any_unique_type:AnyUniqueAliases): def add_any_unique_type(any_unique_type:AnyUniqueAliases):
b_.PrependUint8Slot(43, any_unique_type, 0) b_.PrependUint8Slot(43, any_unique_type, 0)
return this return this
def add_any_unique(any_unique:flatbuffers_offset): def add_any_unique(any_unique:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(44, any_unique) b_.PrependUOffsetTRelativeSlot(44, any_unique)
return this return this
def add_any_ambiguous_type(any_ambiguous_type:AnyAmbiguousAliases): def add_any_ambiguous_type(any_ambiguous_type:AnyAmbiguousAliases):
b_.PrependUint8Slot(45, any_ambiguous_type, 0) b_.PrependUint8Slot(45, any_ambiguous_type, 0)
return this return this
def add_any_ambiguous(any_ambiguous:flatbuffers_offset): def add_any_ambiguous(any_ambiguous:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(46, any_ambiguous) b_.PrependUOffsetTRelativeSlot(46, any_ambiguous)
return this return this
def add_vector_of_enums(vector_of_enums:flatbuffers_offset): def add_vector_of_enums(vector_of_enums:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(47, vector_of_enums) b_.PrependUOffsetTRelativeSlot(47, vector_of_enums)
return this return this
def add_signed_enum(signed_enum:Race): def add_signed_enum(signed_enum:Race):
b_.PrependInt8Slot(48, signed_enum, -1) b_.PrependInt8Slot(48, signed_enum, -1)
return this return this
def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers_offset): def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer) b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer)
return this return this
def add_scalar_key_sorted_tables(scalar_key_sorted_tables:flatbuffers_offset): def add_scalar_key_sorted_tables(scalar_key_sorted_tables:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(50, scalar_key_sorted_tables) b_.PrependUOffsetTRelativeSlot(50, scalar_key_sorted_tables)
return this return this
def add_native_inline(native_inline:flatbuffers_offset): def add_native_inline(native_inline:flatbuffers.offset):
b_.PrependStructSlot(51, native_inline) b_.PrependStructSlot(51, native_inline)
return this return this
def add_long_enum_non_enum_default(long_enum_non_enum_default:LongEnum): def add_long_enum_non_enum_default(long_enum_non_enum_default:LongEnum):
@@ -635,168 +635,168 @@ struct MonsterBuilder:
def end(): def end():
return b_.EndObject() return b_.EndObject()
def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int): def MonsterStartInventoryVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateInventoryVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_) reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTest4Vector(b_:flatbuffers_builder, n_:int): def MonsterStartTest4Vector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 2) b_.StartVector(4, n_, 2)
def MonsterStartTestarrayofstringVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestarrayofstringVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayofstringVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateTestarrayofstringVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestarrayoftablesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayoftablesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateTestarrayoftablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestnestedflatbufferVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestnestedflatbufferVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateTestnestedflatbufferVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateTestnestedflatbufferVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_) reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestarrayofboolsVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestarrayofboolsVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateTestarrayofboolsVector(b_:flatbuffers_builder, v_:[bool]): def MonsterCreateTestarrayofboolsVector(b_:flatbuffers.builder, v_:[bool]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependBool(e_) reverse(v_) e_: b_.PrependBool(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestarrayofstring2Vector(b_:flatbuffers_builder, n_:int): def MonsterStartTestarrayofstring2Vector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateTestarrayofstring2Vector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateTestarrayofstring2Vector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 4) b_.StartVector(8, n_, 4)
def MonsterStartFlexVector(b_:flatbuffers_builder, n_:int): def MonsterStartFlexVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateFlexVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateFlexVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_) reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTest5Vector(b_:flatbuffers_builder, n_:int): def MonsterStartTest5Vector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 2) b_.StartVector(4, n_, 2)
def MonsterStartVectorOfLongsVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfLongsVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfLongsVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateVectorOfLongsVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependInt64(e_) reverse(v_) e_: b_.PrependInt64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfDoublesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfDoublesVector(b_:flatbuffers_builder, v_:[float]): def MonsterCreateVectorOfDoublesVector(b_:flatbuffers.builder, v_:[float]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependFloat64(e_) reverse(v_) e_: b_.PrependFloat64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfReferrablesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfReferrablesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateVectorOfReferrablesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateVectorOfReferrablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfWeakReferencesVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateVectorOfWeakReferencesVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependUint64(e_) reverse(v_) e_: b_.PrependUint64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateVectorOfStrongReferrablesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateVectorOfStrongReferrablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateVectorOfCoOwningReferencesVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependUint64(e_) reverse(v_) e_: b_.PrependUint64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def MonsterCreateVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateVectorOfNonOwningReferencesVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependUint64(e_) reverse(v_) e_: b_.PrependUint64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartVectorOfEnumsVector(b_:flatbuffers_builder, n_:int): def MonsterStartVectorOfEnumsVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[Color]): def MonsterCreateVectorOfEnumsVector(b_:flatbuffers.builder, v_:[Color]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_) reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers_builder, n_:int): def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers_builder, v_:[int]): def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependUint8(e_) reverse(v_) e_: b_.PrependUint8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers_builder, n_:int): def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers.builder, n_:int):
b_.StartVector(4, n_, 4) b_.StartVector(4, n_, 4)
def MonsterCreateScalarKeySortedTablesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): def MonsterCreateScalarKeySortedTablesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):
b_.StartVector(4, v_.length, 4) b_.StartVector(4, v_.length, 4)
reverse(v_) e_: b_.PrependUOffsetTRelative(e_) reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
class TypeAliases : flatbuffers_handle class TypeAliases : flatbuffers.handle
def i8() -> int: def i8() -> int:
return buf_.flatbuffers_field_int8(pos_, 4, 0) return flatbuffers.field_int8(buf_, pos_, 4, 0)
def u8() -> int: def u8() -> int:
return buf_.flatbuffers_field_uint8(pos_, 6, 0) return flatbuffers.field_uint8(buf_, pos_, 6, 0)
def i16() -> int: def i16() -> int:
return buf_.flatbuffers_field_int16(pos_, 8, 0) return flatbuffers.field_int16(buf_, pos_, 8, 0)
def u16() -> int: def u16() -> int:
return buf_.flatbuffers_field_uint16(pos_, 10, 0) return flatbuffers.field_uint16(buf_, pos_, 10, 0)
def i32() -> int: def i32() -> int:
return buf_.flatbuffers_field_int32(pos_, 12, 0) return flatbuffers.field_int32(buf_, pos_, 12, 0)
def u32() -> int: def u32() -> int:
return buf_.flatbuffers_field_uint32(pos_, 14, 0) return flatbuffers.field_uint32(buf_, pos_, 14, 0)
def i64() -> int: def i64() -> int:
return buf_.flatbuffers_field_int64(pos_, 16, 0) return flatbuffers.field_int64(buf_, pos_, 16, 0)
def u64() -> int: def u64() -> int:
return buf_.flatbuffers_field_uint64(pos_, 18, 0) return flatbuffers.field_uint64(buf_, pos_, 18, 0)
def f32() -> float: def f32() -> float:
return buf_.flatbuffers_field_float32(pos_, 20, 0.0) return flatbuffers.field_float32(buf_, pos_, 20, 0.0)
def f64() -> float: def f64() -> float:
return buf_.flatbuffers_field_float64(pos_, 22, 0.0) return flatbuffers.field_float64(buf_, pos_, 22, 0.0)
def v8(i:int) -> int: def v8(i:int) -> int:
return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 24) + i * 1) return read_int8_le(buf_, buf_.flatbuffers.field_vector(pos_, 24) + i * 1)
def v8_length() -> int: def v8_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 24) return flatbuffers.field_vector_len(buf_, pos_, 24)
def vf64(i:int) -> float: def vf64(i:int) -> float:
return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 26) + i * 8) return read_float64_le(buf_, buf_.flatbuffers.field_vector(pos_, 26) + i * 8)
def vf64_length() -> int: def vf64_length() -> int:
return buf_.flatbuffers_field_vector_len(pos_, 26) return flatbuffers.field_vector_len(buf_, pos_, 26)
def GetRootAsTypeAliases(buf:string): return TypeAliases { buf, buf.flatbuffers_indirect(0) } def GetRootAsTypeAliases(buf:string): return TypeAliases { buf, flatbuffers.indirect(buf, 0) }
struct TypeAliasesBuilder: struct TypeAliasesBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(12) b_.StartObject(12)
return this return this
@@ -830,25 +830,25 @@ struct TypeAliasesBuilder:
def add_f64(f64:float): def add_f64(f64:float):
b_.PrependFloat64Slot(9, f64, 0.0) b_.PrependFloat64Slot(9, f64, 0.0)
return this return this
def add_v8(v8:flatbuffers_offset): def add_v8(v8:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(10, v8) b_.PrependUOffsetTRelativeSlot(10, v8)
return this return this
def add_vf64(vf64:flatbuffers_offset): def add_vf64(vf64:flatbuffers.offset):
b_.PrependUOffsetTRelativeSlot(11, vf64) b_.PrependUOffsetTRelativeSlot(11, vf64)
return this return this
def end(): def end():
return b_.EndObject() return b_.EndObject()
def TypeAliasesStartV8Vector(b_:flatbuffers_builder, n_:int): def TypeAliasesStartV8Vector(b_:flatbuffers.builder, n_:int):
b_.StartVector(1, n_, 1) b_.StartVector(1, n_, 1)
def TypeAliasesCreateV8Vector(b_:flatbuffers_builder, v_:[int]): def TypeAliasesCreateV8Vector(b_:flatbuffers.builder, v_:[int]):
b_.StartVector(1, v_.length, 1) b_.StartVector(1, v_.length, 1)
reverse(v_) e_: b_.PrependInt8(e_) reverse(v_) e_: b_.PrependInt8(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)
def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int): def TypeAliasesStartVf64Vector(b_:flatbuffers.builder, n_:int):
b_.StartVector(8, n_, 8) b_.StartVector(8, n_, 8)
def TypeAliasesCreateVf64Vector(b_:flatbuffers_builder, v_:[float]): def TypeAliasesCreateVf64Vector(b_:flatbuffers.builder, v_:[float]):
b_.StartVector(8, v_.length, 8) b_.StartVector(8, v_.length, 8)
reverse(v_) e_: b_.PrependFloat64(e_) reverse(v_) e_: b_.PrependFloat64(e_)
return b_.EndVector(v_.length) return b_.EndVector(v_.length)

78
tests/optional_scalars_generated.lobster
View File

@@ -10,84 +10,84 @@ enum OptionalByte:
class ScalarStuff class ScalarStuff
class ScalarStuff : flatbuffers_handle class ScalarStuff : flatbuffers.handle
def just_i8() -> int: def just_i8() -> int:
return buf_.flatbuffers_field_int8(pos_, 4, 0) return flatbuffers.field_int8(buf_, pos_, 4, 0)
def maybe_i8() -> int, bool: def maybe_i8() -> int, bool:
return buf_.flatbuffers_field_int8(pos_, 6, 0), buf_.flatbuffers_field_present(pos_, 6) return flatbuffers.field_int8(buf_, pos_, 6, 0), flatbuffers.field_present(buf_, pos_, 6)
def default_i8() -> int: def default_i8() -> int:
return buf_.flatbuffers_field_int8(pos_, 8, 42) return flatbuffers.field_int8(buf_, pos_, 8, 42)
def just_u8() -> int: def just_u8() -> int:
return buf_.flatbuffers_field_uint8(pos_, 10, 0) return flatbuffers.field_uint8(buf_, pos_, 10, 0)
def maybe_u8() -> int, bool: def maybe_u8() -> int, bool:
return buf_.flatbuffers_field_uint8(pos_, 12, 0), buf_.flatbuffers_field_present(pos_, 12) return flatbuffers.field_uint8(buf_, pos_, 12, 0), flatbuffers.field_present(buf_, pos_, 12)
def default_u8() -> int: def default_u8() -> int:
return buf_.flatbuffers_field_uint8(pos_, 14, 42) return flatbuffers.field_uint8(buf_, pos_, 14, 42)
def just_i16() -> int: def just_i16() -> int:
return buf_.flatbuffers_field_int16(pos_, 16, 0) return flatbuffers.field_int16(buf_, pos_, 16, 0)
def maybe_i16() -> int, bool: def maybe_i16() -> int, bool:
return buf_.flatbuffers_field_int16(pos_, 18, 0), buf_.flatbuffers_field_present(pos_, 18) return flatbuffers.field_int16(buf_, pos_, 18, 0), flatbuffers.field_present(buf_, pos_, 18)
def default_i16() -> int: def default_i16() -> int:
return buf_.flatbuffers_field_int16(pos_, 20, 42) return flatbuffers.field_int16(buf_, pos_, 20, 42)
def just_u16() -> int: def just_u16() -> int:
return buf_.flatbuffers_field_uint16(pos_, 22, 0) return flatbuffers.field_uint16(buf_, pos_, 22, 0)
def maybe_u16() -> int, bool: def maybe_u16() -> int, bool:
return buf_.flatbuffers_field_uint16(pos_, 24, 0), buf_.flatbuffers_field_present(pos_, 24) return flatbuffers.field_uint16(buf_, pos_, 24, 0), flatbuffers.field_present(buf_, pos_, 24)
def default_u16() -> int: def default_u16() -> int:
return buf_.flatbuffers_field_uint16(pos_, 26, 42) return flatbuffers.field_uint16(buf_, pos_, 26, 42)
def just_i32() -> int: def just_i32() -> int:
return buf_.flatbuffers_field_int32(pos_, 28, 0) return flatbuffers.field_int32(buf_, pos_, 28, 0)
def maybe_i32() -> int, bool: def maybe_i32() -> int, bool:
return buf_.flatbuffers_field_int32(pos_, 30, 0), buf_.flatbuffers_field_present(pos_, 30) return flatbuffers.field_int32(buf_, pos_, 30, 0), flatbuffers.field_present(buf_, pos_, 30)
def default_i32() -> int: def default_i32() -> int:
return buf_.flatbuffers_field_int32(pos_, 32, 42) return flatbuffers.field_int32(buf_, pos_, 32, 42)
def just_u32() -> int: def just_u32() -> int:
return buf_.flatbuffers_field_uint32(pos_, 34, 0) return flatbuffers.field_uint32(buf_, pos_, 34, 0)
def maybe_u32() -> int, bool: def maybe_u32() -> int, bool:
return buf_.flatbuffers_field_uint32(pos_, 36, 0), buf_.flatbuffers_field_present(pos_, 36) return flatbuffers.field_uint32(buf_, pos_, 36, 0), flatbuffers.field_present(buf_, pos_, 36)
def default_u32() -> int: def default_u32() -> int:
return buf_.flatbuffers_field_uint32(pos_, 38, 42) return flatbuffers.field_uint32(buf_, pos_, 38, 42)
def just_i64() -> int: def just_i64() -> int:
return buf_.flatbuffers_field_int64(pos_, 40, 0) return flatbuffers.field_int64(buf_, pos_, 40, 0)
def maybe_i64() -> int, bool: def maybe_i64() -> int, bool:
return buf_.flatbuffers_field_int64(pos_, 42, 0), buf_.flatbuffers_field_present(pos_, 42) return flatbuffers.field_int64(buf_, pos_, 42, 0), flatbuffers.field_present(buf_, pos_, 42)
def default_i64() -> int: def default_i64() -> int:
return buf_.flatbuffers_field_int64(pos_, 44, 42) return flatbuffers.field_int64(buf_, pos_, 44, 42)
def just_u64() -> int: def just_u64() -> int:
return buf_.flatbuffers_field_uint64(pos_, 46, 0) return flatbuffers.field_uint64(buf_, pos_, 46, 0)
def maybe_u64() -> int, bool: def maybe_u64() -> int, bool:
return buf_.flatbuffers_field_uint64(pos_, 48, 0), buf_.flatbuffers_field_present(pos_, 48) return flatbuffers.field_uint64(buf_, pos_, 48, 0), flatbuffers.field_present(buf_, pos_, 48)
def default_u64() -> int: def default_u64() -> int:
return buf_.flatbuffers_field_uint64(pos_, 50, 42) return flatbuffers.field_uint64(buf_, pos_, 50, 42)
def just_f32() -> float: def just_f32() -> float:
return buf_.flatbuffers_field_float32(pos_, 52, 0.0) return flatbuffers.field_float32(buf_, pos_, 52, 0.0)
def maybe_f32() -> float, bool: def maybe_f32() -> float, bool:
return buf_.flatbuffers_field_float32(pos_, 54, 0), buf_.flatbuffers_field_present(pos_, 54) return flatbuffers.field_float32(buf_, pos_, 54, 0.0), flatbuffers.field_present(buf_, pos_, 54)
def default_f32() -> float: def default_f32() -> float:
return buf_.flatbuffers_field_float32(pos_, 56, 42.0) return flatbuffers.field_float32(buf_, pos_, 56, 42.0)
def just_f64() -> float: def just_f64() -> float:
return buf_.flatbuffers_field_float64(pos_, 58, 0.0) return flatbuffers.field_float64(buf_, pos_, 58, 0.0)
def maybe_f64() -> float, bool: def maybe_f64() -> float, bool:
return buf_.flatbuffers_field_float64(pos_, 60, 0), buf_.flatbuffers_field_present(pos_, 60) return flatbuffers.field_float64(buf_, pos_, 60, 0.0), flatbuffers.field_present(buf_, pos_, 60)
def default_f64() -> float: def default_f64() -> float:
return buf_.flatbuffers_field_float64(pos_, 62, 42.0) return flatbuffers.field_float64(buf_, pos_, 62, 42.0)
def just_bool() -> bool: def just_bool() -> bool:
return bool(buf_.flatbuffers_field_int8(pos_, 64, 0)) return bool(flatbuffers.field_int8(buf_, pos_, 64, 0))
def maybe_bool() -> bool, bool: def maybe_bool() -> bool, bool:
return bool(buf_.flatbuffers_field_int8(pos_, 66, 0)), buf_.flatbuffers_field_present(pos_, 66) return bool(flatbuffers.field_int8(buf_, pos_, 66, 0)), flatbuffers.field_present(buf_, pos_, 66)
def default_bool() -> bool: def default_bool() -> bool:
return bool(buf_.flatbuffers_field_int8(pos_, 68, 1)) return bool(flatbuffers.field_int8(buf_, pos_, 68, 1))
def just_enum() -> OptionalByte: def just_enum() -> OptionalByte:
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 70, 0)) return OptionalByte(flatbuffers.field_int8(buf_, pos_, 70, 0))
def maybe_enum() -> OptionalByte, bool: def maybe_enum() -> OptionalByte, bool:
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 72, 0)), buf_.flatbuffers_field_present(pos_, 72) return OptionalByte(flatbuffers.field_int8(buf_, pos_, 72, 0)), flatbuffers.field_present(buf_, pos_, 72)
def default_enum() -> OptionalByte: def default_enum() -> OptionalByte:
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 74, 1)) return OptionalByte(flatbuffers.field_int8(buf_, pos_, 74, 1))
def GetRootAsScalarStuff(buf:string): return ScalarStuff { buf, buf.flatbuffers_indirect(0) } def GetRootAsScalarStuff(buf:string): return ScalarStuff { buf, flatbuffers.indirect(buf, 0) }
struct ScalarStuffBuilder: struct ScalarStuffBuilder:
b_:flatbuffers_builder b_:flatbuffers.builder
def start(): def start():
b_.StartObject(36) b_.StartObject(36)
return this return this