diff --git a/src/idl_gen_lobster.cpp b/src/idl_gen_lobster.cpp index 37c95e960..c89e7bb46 100644 --- a/src/idl_gen_lobster.cpp +++ b/src/idl_gen_lobster.cpp @@ -31,7 +31,7 @@ class LobsterGenerator : public BaseGenerator { public: LobsterGenerator(const Parser &parser, const std::string &path, const std::string &file_name) - : BaseGenerator(parser, path, file_name, "" /* not used */, "_", + : BaseGenerator(parser, path, file_name, "" /* not used */, ".", "lobster") { static const char *const keywords[] = { "nil", "true", "false", "return", "struct", "class", @@ -79,7 +79,7 @@ class LobsterGenerator : public BaseGenerator { if (IsBool(type.base_type)) return "bool"; if (IsScalar(type.base_type) && 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"; return "int"; } @@ -119,15 +119,17 @@ class LobsterGenerator : public BaseGenerator { offsets + ")"; } else { - auto defval = field.IsOptional() ? "0" : field.value.constant; - acc = "buf_.flatbuffers_field_" + GenTypeName(field.value.type) + - "(pos_, " + offsets + ", " + defval + ")"; + auto defval = field.IsOptional() + ? (IsFloat(field.value.type.base_type) ? "0.0" : "0") + : 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 (field.value.type.enum_def) acc = NormalizedName(*field.value.type.enum_def) + "(" + acc + ")"; if (field.IsOptional()) { - acc += ", buf_.flatbuffers_field_present(pos_, " + offsets + ")"; + acc += ", flatbuffers.field_present(buf_, pos_, " + offsets + ")"; code += def + "() -> " + LobsterType(field.value.type) + ", bool:\n return " + acc + "\n"; } else { @@ -144,9 +146,9 @@ class LobsterGenerator : public BaseGenerator { code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n"; } else { 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") + - "(pos_, " + offsets + ")\n return if o: " + name + + "(buf_, pos_, " + offsets + ")\n return if o: " + name + " { buf_, o } else: nil\n"; } break; @@ -154,16 +156,16 @@ class LobsterGenerator : public BaseGenerator { case BASE_TYPE_STRING: code += def + "() -> string:\n return " - "buf_.flatbuffers_field_string(pos_, " + + "flatbuffers.field_string(buf_, pos_, " + offsets + ")\n"; break; case BASE_TYPE_VECTOR: { auto vectortype = field.value.type.VectorType(); 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)); if (!(vectortype.struct_def->fixed)) { - start = "buf_.flatbuffers_indirect(" + start + ")"; + start = "flatbuffers.indirect(buf_, " + start + ")"; } code += def + "(i:int) -> " + NamespacedName(*field.value.type.struct_def) + @@ -173,13 +175,13 @@ class LobsterGenerator : public BaseGenerator { } else { if (IsString(vectortype)) { code += def + "(i:int) -> string:\n return "; - code += "buf_.flatbuffers_string"; + code += "flatbuffers.string"; } else { code += def + "(i:int) -> " + LobsterType(vectortype) + ":\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"; } break; @@ -191,7 +193,7 @@ class LobsterGenerator : public BaseGenerator { if (ev.IsNonZero()) { code += def + "_as_" + ev.name + "():\n return " + NamespacedName(*ev.union_type.struct_def) + - " { buf_, buf_.flatbuffers_field_table(pos_, " + offsets + + " { buf_, flatbuffers.field_table(buf_, pos_, " + offsets + ") }\n"; } } @@ -202,7 +204,7 @@ class LobsterGenerator : public BaseGenerator { if (IsVector(field.value.type)) { code += def + "_length() -> int:\n return " - "buf_.flatbuffers_field_vector_len(pos_, " + + "flatbuffers.field_vector_len(buf_, pos_, " + offsets + ")\n"; } } @@ -211,7 +213,7 @@ class LobsterGenerator : public BaseGenerator { void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) { std::string &code = *code_ptr; code += "struct " + NormalizedName(struct_def) + - "Builder:\n b_:flatbuffers_builder\n"; + "Builder:\n b_:flatbuffers.builder\n"; code += " def start():\n b_.StartObject(" + NumToString(struct_def.fields.vec.size()) + ")\n return this\n"; @@ -236,7 +238,7 @@ class LobsterGenerator : public BaseGenerator { if (IsVector(field.value.type)) { code += "def " + NormalizedName(struct_def) + "Start" + 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 alignment = InlineAlignment(vector_type); auto elem_size = InlineSize(vector_type); @@ -246,7 +248,7 @@ class LobsterGenerator : public BaseGenerator { !vector_type.struct_def->fixed) { code += "def " + NormalizedName(struct_def) + "Create" + ConvertCase(NormalizedName(field), Case::kUpperCamel) + - "Vector(b_:flatbuffers_builder, v_:[" + + "Vector(b_:flatbuffers.builder, v_:[" + LobsterType(vector_type) + "]):\n b_.StartVector(" + NumToString(elem_size) + ", v_.length, " + NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" + @@ -271,7 +273,7 @@ class LobsterGenerator : public BaseGenerator { std::string &code = *code_ptr; CheckNameSpace(struct_def, &code); 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(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; @@ -284,7 +286,7 @@ class LobsterGenerator : public BaseGenerator { // the root type. code += "def GetRootAs" + 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) { // create a struct constructor function @@ -360,7 +362,7 @@ class LobsterGenerator : public BaseGenerator { void GenStructBuilder(const StructDef &struct_def, std::string *code_ptr) { std::string &code = *code_ptr; code += - "def Create" + NormalizedName(struct_def) + "(b_:flatbuffers_builder"; + "def Create" + NormalizedName(struct_def) + "(b_:flatbuffers.builder"; StructBuilderArgs(struct_def, "", code_ptr); code += "):\n"; StructBuilderBody(struct_def, "", code_ptr); diff --git a/tests/LobsterTest.bat b/tests/LobsterTest.bat new file mode 100644 index 000000000..785f34c65 --- /dev/null +++ b/tests/LobsterTest.bat @@ -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 diff --git a/tests/lobstertest.lobster b/tests/lobstertest.lobster index 454c2b894..4bdf32ad1 100644 --- a/tests/lobstertest.lobster +++ b/tests/lobstertest.lobster @@ -18,9 +18,9 @@ import optional_scalars_generated def check_read_buffer(buf): // 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.mana == 150 @@ -39,7 +39,7 @@ def check_read_buffer(buf): assert t.a == 5 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.inventory_length == 5 @@ -48,7 +48,7 @@ def check_read_buffer(buf): for(5) i: 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))) assert monster.test4_length == 2 @@ -66,40 +66,40 @@ def check_read_buffer(buf): def make_monster_from_generated_code(): // Use generated code to build the example Monster. - let b = flatbuffers_builder {} + let b = flatbuffers.builder {} let name = b.CreateString("MyMonster") 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() .add_name(fred) .end() - b.MyGame_Example_MonsterStartTest4Vector(2) - b.MyGame_Example_CreateTest(10, 20) - b.MyGame_Example_CreateTest(30, 40) + b.MyGame.Example.MonsterStartTest4Vector(2) + b.MyGame.Example.CreateTest(10, 20) + b.MyGame.Example.CreateTest(30, 40) 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") ]) - let vector_of_longs = b.MyGame_Example_MonsterCreateVectorOfLongsVector( + let vector_of_longs = b.MyGame.Example.MonsterCreateVectorOfLongsVector( [ 1, 100, 10000, 1000000, 100000000 ]) - let vector_of_doubles = b.MyGame_Example_MonsterCreateVectorOfDoublesVector( - [ -1.7976931348623157e+308, 0, 1.7976931348623157e+308 ]) + let vector_of_doubles = b.MyGame.Example.MonsterCreateVectorOfDoublesVector( + [ -1.7976931348623157e+308, 0.0, 1.7976931348623157e+308 ]) - let mon = MyGame_Example_MonsterBuilder { b } + let mon = MyGame.Example.MonsterBuilder { b } .start() - .add_pos(b.MyGame_Example_CreateVec3(1.0, 2.0, 3.0, 3.0, - MyGame_Example_Color_Green, 5, 6)) + .add_pos(b.MyGame.Example.CreateVec3(1.0, 2.0, 3.0, 3.0, + MyGame.Example.Color_Green, 5, 6)) .add_hp(80) .add_name(name) .add_inventory(inv) - .add_test_type(MyGame_Example_Any_Monster) + .add_test_type(MyGame.Example.Any_Monster) .add_test(mon2) .add_test4(test4) .add_testarrayofstring(test_array_of_string) @@ -113,8 +113,8 @@ def make_monster_from_generated_code(): def test_optional_scalars(): def build(add_fields): - let b = flatbuffers_builder {} - let ss = optional_scalars_ScalarStuffBuilder { b }.start() + let b = flatbuffers.builder {} + let ss = optional_scalars.ScalarStuffBuilder { b }.start() if add_fields: ss.add_just_i8(1) ss.add_maybe_i8(1) @@ -125,13 +125,13 @@ def test_optional_scalars(): ss.add_just_bool(true) ss.add_maybe_bool(true) ss.add_default_bool(true) - ss.add_just_enum(optional_scalars_OptionalByte_Two) - ss.add_maybe_enum(optional_scalars_OptionalByte_Two) - ss.add_default_enum(optional_scalars_OptionalByte_Two) + ss.add_just_enum(optional_scalars.OptionalByte_Two) + ss.add_maybe_enum(optional_scalars.OptionalByte_Two) + ss.add_default_enum(optional_scalars.OptionalByte_Two) b.Finish(ss.end(), "NULL") let buf = b.SizedCopy() - assert flatbuffers_has_identifier(buf, "NULL") - return optional_scalars_GetRootAsScalarStuff(buf) + assert flatbuffers.has_identifier(buf, "NULL") + return optional_scalars.GetRootAsScalarStuff(buf) var root = build(true) @@ -147,9 +147,9 @@ def test_optional_scalars(): var maybe_val_bool, maybe_present_bool = root.maybe_bool() 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() - 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) @@ -165,9 +165,9 @@ def test_optional_scalars(): maybe_val_bool, maybe_present_bool = root.maybe_bool() 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() - 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) @@ -188,10 +188,10 @@ let schema = read_file("monster_test.fbs") assert schema let includedirs = [ "include_test" ] // 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 // 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 // Check the resulting binary again (full roundtrip test): check_read_buffer(fb3) diff --git a/tests/monster_test_generated.lobster b/tests/monster_test_generated.lobster index d6390fd8b..9d3cccdee 100644 --- a/tests/monster_test_generated.lobster +++ b/tests/monster_test_generated.lobster @@ -1,7 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify import flatbuffers -namespace MyGame_Example +namespace MyGame.Example /// Composite components of Monster color. enum Color: @@ -45,11 +45,11 @@ namespace MyGame class InParentNamespace -namespace MyGame_Example2 +namespace MyGame.Example2 class Monster -namespace MyGame_Example +namespace MyGame.Example class Test @@ -73,55 +73,55 @@ class TypeAliases 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(0) return this def end(): 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(0) return this def end(): return b_.EndObject() -namespace MyGame_Example +namespace MyGame.Example -class Test : flatbuffers_handle +class Test : flatbuffers.handle def a() -> int: return buf_.read_int16_le(pos_ + 0) def b() -> int: 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_.Pad(1) b_.PrependInt8(b) b_.PrependInt16(a) return b_.Offset() -class TestSimpleTableWithEnum : flatbuffers_handle +class TestSimpleTableWithEnum : flatbuffers.handle 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(1) return this @@ -131,7 +131,7 @@ struct TestSimpleTableWithEnumBuilder: def end(): return b_.EndObject() -class Vec3 : flatbuffers_handle +class Vec3 : flatbuffers.handle def x() -> float: return buf_.read_float32_le(pos_ + 0) def y() -> float: @@ -142,10 +142,10 @@ class Vec3 : flatbuffers_handle return buf_.read_float64_le(pos_ + 16) def test2() -> Color: return Color(buf_.read_uint8_le(pos_ + 24)) - def test3() -> MyGame_Example_Test: - return MyGame_Example_Test{ buf_, pos_ + 26 } + def test3() -> MyGame.Example.Test: + 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_.Pad(2) 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) return b_.Offset() -class Ability : flatbuffers_handle +class Ability : flatbuffers.handle def id() -> int: return buf_.read_uint32_le(pos_ + 0) def distance() -> int: 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_.PrependUint32(distance) b_.PrependUint32(id) return b_.Offset() -class StructOfStructs : flatbuffers_handle - def a() -> MyGame_Example_Ability: - return MyGame_Example_Ability{ buf_, pos_ + 0 } - def b() -> MyGame_Example_Test: - return MyGame_Example_Test{ buf_, pos_ + 8 } - def c() -> MyGame_Example_Ability: - return MyGame_Example_Ability{ buf_, pos_ + 12 } +class StructOfStructs : flatbuffers.handle + def a() -> MyGame.Example.Ability: + return MyGame.Example.Ability{ buf_, pos_ + 0 } + def b() -> MyGame.Example.Test: + return MyGame.Example.Test{ buf_, pos_ + 8 } + def c() -> MyGame.Example.Ability: + 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, 8) 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) return b_.Offset() -class StructOfStructsOfStructs : flatbuffers_handle - def a() -> MyGame_Example_StructOfStructs: - return MyGame_Example_StructOfStructs{ buf_, pos_ + 0 } +class StructOfStructsOfStructs : flatbuffers.handle + def a() -> MyGame.Example.StructOfStructs: + 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, 8) @@ -214,22 +214,22 @@ def CreateStructOfStructsOfStructs(b_:flatbuffers_builder, a_a_id:int, a_a_dista b_.PrependUint32(a_a_id) return b_.Offset() -class Stat : flatbuffers_handle +class Stat : flatbuffers.handle def id() -> string: - return buf_.flatbuffers_field_string(pos_, 4) + return flatbuffers.field_string(buf_, pos_, 4) def val() -> int: - return buf_.flatbuffers_field_int64(pos_, 6, 0) + return flatbuffers.field_int64(buf_, pos_, 6, 0) 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(3) return this - def add_id(id:flatbuffers_offset): + def add_id(id:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(0, id) return this def add_val(val:int): @@ -241,14 +241,14 @@ struct StatBuilder: def end(): return b_.EndObject() -class Referrable : flatbuffers_handle +class Referrable : flatbuffers.handle 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(1) return this @@ -259,197 +259,197 @@ struct ReferrableBuilder: return b_.EndObject() /// an example documentation comment: "monster object" -class Monster : flatbuffers_handle - def pos() -> MyGame_Example_Vec3?: - let o = buf_.flatbuffers_field_struct(pos_, 4) - return if o: MyGame_Example_Vec3 { buf_, o } else: nil +class Monster : flatbuffers.handle + def pos() -> MyGame.Example.Vec3?: + let o = flatbuffers.field_struct(buf_, pos_, 4) + return if o: MyGame.Example.Vec3 { buf_, o } else: nil def mana() -> int: - return buf_.flatbuffers_field_int16(pos_, 6, 150) + return flatbuffers.field_int16(buf_, pos_, 6, 150) def hp() -> int: - return buf_.flatbuffers_field_int16(pos_, 8, 100) + return flatbuffers.field_int16(buf_, pos_, 8, 100) def name() -> string: - return buf_.flatbuffers_field_string(pos_, 10) + return flatbuffers.field_string(buf_, pos_, 10) 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: - return buf_.flatbuffers_field_vector_len(pos_, 14) + return flatbuffers.field_vector_len(buf_, pos_, 14) 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: - return Any(buf_.flatbuffers_field_uint8(pos_, 18, 0)) + return Any(flatbuffers.field_uint8(buf_, pos_, 18, 0)) 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(): - 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(): - return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) } - def test4(i:int) -> MyGame_Example_Test: - return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 } + return MyGame.Example2.Monster { buf_, flatbuffers.field_table(buf_, pos_, 20) } + def test4(i:int) -> MyGame.Example.Test: + return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 22) + i * 4 } 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: - 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: - 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 /// multiline too - def testarrayoftables(i:int) -> MyGame_Example_Monster: - return MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) } + def testarrayoftables(i:int) -> MyGame.Example.Monster: + return MyGame.Example.Monster { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 26) + i * 4) } def testarrayoftables_length() -> int: - return buf_.flatbuffers_field_vector_len(pos_, 26) - def enemy() -> MyGame_Example_Monster?: - let o = buf_.flatbuffers_field_table(pos_, 28) - return if o: MyGame_Example_Monster { buf_, o } else: nil + return flatbuffers.field_vector_len(buf_, pos_, 26) + def enemy() -> MyGame.Example.Monster?: + let o = flatbuffers.field_table(buf_, pos_, 28) + return if o: MyGame.Example.Monster { buf_, o } else: nil 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: - return buf_.flatbuffers_field_vector_len(pos_, 30) - def testempty() -> MyGame_Example_Stat?: - let o = buf_.flatbuffers_field_table(pos_, 32) - return if o: MyGame_Example_Stat { buf_, o } else: nil + return flatbuffers.field_vector_len(buf_, pos_, 30) + def testempty() -> MyGame.Example.Stat?: + let o = flatbuffers.field_table(buf_, pos_, 32) + return if o: MyGame.Example.Stat { buf_, o } else: nil 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: - return buf_.flatbuffers_field_int32(pos_, 36, 0) + return flatbuffers.field_int32(buf_, pos_, 36, 0) def testhashu32_fnv1() -> int: - return buf_.flatbuffers_field_uint32(pos_, 38, 0) + return flatbuffers.field_uint32(buf_, pos_, 38, 0) def testhashs64_fnv1() -> int: - return buf_.flatbuffers_field_int64(pos_, 40, 0) + return flatbuffers.field_int64(buf_, pos_, 40, 0) def testhashu64_fnv1() -> int: - return buf_.flatbuffers_field_uint64(pos_, 42, 0) + return flatbuffers.field_uint64(buf_, pos_, 42, 0) def testhashs32_fnv1a() -> int: - return buf_.flatbuffers_field_int32(pos_, 44, 0) + return flatbuffers.field_int32(buf_, pos_, 44, 0) def testhashu32_fnv1a() -> int: - return buf_.flatbuffers_field_uint32(pos_, 46, 0) + return flatbuffers.field_uint32(buf_, pos_, 46, 0) def testhashs64_fnv1a() -> int: - return buf_.flatbuffers_field_int64(pos_, 48, 0) + return flatbuffers.field_int64(buf_, pos_, 48, 0) 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 52) + return flatbuffers.field_vector_len(buf_, pos_, 52) def testf() -> float: - return buf_.flatbuffers_field_float32(pos_, 54, 3.14159) + return flatbuffers.field_float32(buf_, pos_, 54, 3.14159) def testf2() -> float: - return buf_.flatbuffers_field_float32(pos_, 56, 3.0) + return flatbuffers.field_float32(buf_, pos_, 56, 3.0) 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 60) - def testarrayofsortedstruct(i:int) -> MyGame_Example_Ability: - return MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 } + return flatbuffers.field_vector_len(buf_, pos_, 60) + def testarrayofsortedstruct(i:int) -> MyGame.Example.Ability: + return MyGame.Example.Ability { buf_, flatbuffers.field_vector(buf_, pos_, 62) + i * 8 } 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 64) - def test5(i:int) -> MyGame_Example_Test: - return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 } + return flatbuffers.field_vector_len(buf_, pos_, 64) + def test5(i:int) -> MyGame.Example.Test: + return MyGame.Example.Test { buf_, flatbuffers.field_vector(buf_, pos_, 66) + i * 4 } 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 68) + return flatbuffers.field_vector_len(buf_, pos_, 68) 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: - return buf_.flatbuffers_field_vector_len(pos_, 70) - def parent_namespace_test() -> MyGame_InParentNamespace?: - let o = buf_.flatbuffers_field_table(pos_, 72) - return if o: MyGame_InParentNamespace { buf_, o } else: nil - 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 flatbuffers.field_vector_len(buf_, pos_, 70) + def parent_namespace_test() -> MyGame.InParentNamespace?: + let o = flatbuffers.field_table(buf_, pos_, 72) + return if o: MyGame.InParentNamespace { buf_, o } else: nil + def vector_of_referrables(i:int) -> MyGame.Example.Referrable: + return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 74) + i * 4) } 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: - return buf_.flatbuffers_field_uint64(pos_, 76, 0) + return flatbuffers.field_uint64(buf_, pos_, 76, 0) 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: - return buf_.flatbuffers_field_vector_len(pos_, 78) - 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 flatbuffers.field_vector_len(buf_, pos_, 78) + def vector_of_strong_referrables(i:int) -> MyGame.Example.Referrable: + return MyGame.Example.Referrable { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 80) + i * 4) } 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: - 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 84) + return flatbuffers.field_vector_len(buf_, pos_, 84) 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 88) + return flatbuffers.field_vector_len(buf_, pos_, 88) 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(): - 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(): - 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(): - 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: - return AnyAmbiguousAliases(buf_.flatbuffers_field_uint8(pos_, 94, 0)) + return AnyAmbiguousAliases(flatbuffers.field_uint8(buf_, pos_, 94, 0)) 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(): - 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(): - 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 98) + return flatbuffers.field_vector_len(buf_, pos_, 98) 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 102) - 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 flatbuffers.field_vector_len(buf_, pos_, 102) + def scalar_key_sorted_tables(i:int) -> MyGame.Example.Stat: + return MyGame.Example.Stat { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 104) + i * 4) } def scalar_key_sorted_tables_length() -> int: - return buf_.flatbuffers_field_vector_len(pos_, 104) - def native_inline() -> MyGame_Example_Test?: - let o = buf_.flatbuffers_field_struct(pos_, 106) - return if o: MyGame_Example_Test { buf_, o } else: nil + return flatbuffers.field_vector_len(buf_, pos_, 104) + def native_inline() -> MyGame.Example.Test?: + let o = flatbuffers.field_struct(buf_, pos_, 106) + return if o: MyGame.Example.Test { buf_, o } else: nil 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: - return LongEnum(buf_.flatbuffers_field_uint64(pos_, 110, 2)) + return LongEnum(flatbuffers.field_uint64(buf_, pos_, 110, 2)) def nan_default() -> float: - return buf_.flatbuffers_field_float32(pos_, 112, nan) + return flatbuffers.field_float32(buf_, pos_, 112, nan) 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: - return buf_.flatbuffers_field_float32(pos_, 116, +inf) + return flatbuffers.field_float32(buf_, pos_, 116, +inf) 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: - return buf_.flatbuffers_field_float32(pos_, 120, +infinity) + return flatbuffers.field_float32(buf_, pos_, 120, +infinity) 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: - return buf_.flatbuffers_field_float32(pos_, 124, -infinity) + return flatbuffers.field_float32(buf_, pos_, 124, -infinity) 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(62) return this - def add_pos(pos:flatbuffers_offset): + def add_pos(pos:flatbuffers.offset): b_.PrependStructSlot(0, pos) return this def add_mana(mana:int): @@ -458,10 +458,10 @@ struct MonsterBuilder: def add_hp(hp:int): b_.PrependInt16Slot(2, hp, 100) return this - def add_name(name:flatbuffers_offset): + def add_name(name:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(3, name) return this - def add_inventory(inventory:flatbuffers_offset): + def add_inventory(inventory:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(5, inventory) return this def add_color(color:Color): @@ -470,25 +470,25 @@ struct MonsterBuilder: def add_test_type(test_type:Any): b_.PrependUint8Slot(7, test_type, 0) return this - def add_test(test:flatbuffers_offset): + def add_test(test:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(8, test) return this - def add_test4(test4:flatbuffers_offset): + def add_test4(test4:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(9, test4) return this - def add_testarrayofstring(testarrayofstring:flatbuffers_offset): + def add_testarrayofstring(testarrayofstring:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(10, testarrayofstring) return this - def add_testarrayoftables(testarrayoftables:flatbuffers_offset): + def add_testarrayoftables(testarrayoftables:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(11, testarrayoftables) return this - def add_enemy(enemy:flatbuffers_offset): + def add_enemy(enemy:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(12, enemy) return this - def add_testnestedflatbuffer(testnestedflatbuffer:flatbuffers_offset): + def add_testnestedflatbuffer(testnestedflatbuffer:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(13, testnestedflatbuffer) return this - def add_testempty(testempty:flatbuffers_offset): + def add_testempty(testempty:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(14, testempty) return this def add_testbool(testbool:bool): @@ -518,7 +518,7 @@ struct MonsterBuilder: def add_testhashu64_fnv1a(testhashu64_fnv1a:int): b_.PrependUint64Slot(23, testhashu64_fnv1a, 0) return this - def add_testarrayofbools(testarrayofbools:flatbuffers_offset): + def add_testarrayofbools(testarrayofbools:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(24, testarrayofbools) return this def add_testf(testf:float): @@ -530,76 +530,76 @@ struct MonsterBuilder: def add_testf3(testf3:float): b_.PrependFloat32Slot(27, testf3, 0.0) return this - def add_testarrayofstring2(testarrayofstring2:flatbuffers_offset): + def add_testarrayofstring2(testarrayofstring2:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(28, testarrayofstring2) return this - def add_testarrayofsortedstruct(testarrayofsortedstruct:flatbuffers_offset): + def add_testarrayofsortedstruct(testarrayofsortedstruct:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct) return this - def add_flex(flex:flatbuffers_offset): + def add_flex(flex:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(30, flex) return this - def add_test5(test5:flatbuffers_offset): + def add_test5(test5:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(31, test5) 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) 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) 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) 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) return this def add_single_weak_reference(single_weak_reference:int): b_.PrependUint64Slot(36, single_weak_reference, 0) 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) 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) return this def add_co_owning_reference(co_owning_reference:int): b_.PrependUint64Slot(39, co_owning_reference, 0) 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) return this def add_non_owning_reference(non_owning_reference:int): b_.PrependUint64Slot(41, non_owning_reference, 0) 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) return this def add_any_unique_type(any_unique_type:AnyUniqueAliases): b_.PrependUint8Slot(43, any_unique_type, 0) return this - def add_any_unique(any_unique:flatbuffers_offset): + def add_any_unique(any_unique:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(44, any_unique) return this def add_any_ambiguous_type(any_ambiguous_type:AnyAmbiguousAliases): b_.PrependUint8Slot(45, any_ambiguous_type, 0) return this - def add_any_ambiguous(any_ambiguous:flatbuffers_offset): + def add_any_ambiguous(any_ambiguous:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(46, any_ambiguous) 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) return this def add_signed_enum(signed_enum:Race): b_.PrependInt8Slot(48, signed_enum, -1) return this - def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers_offset): + def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer) 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) return this - def add_native_inline(native_inline:flatbuffers_offset): + def add_native_inline(native_inline:flatbuffers.offset): b_.PrependStructSlot(51, native_inline) return this def add_long_enum_non_enum_default(long_enum_non_enum_default:LongEnum): @@ -635,168 +635,168 @@ struct MonsterBuilder: def end(): return b_.EndObject() -def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int): +def MonsterStartInventoryVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint8(e_) return b_.EndVector(v_.length) -def MonsterStartTest4Vector(b_:flatbuffers_builder, n_:int): +def MonsterStartTest4Vector(b_:flatbuffers.builder, n_:int): b_.StartVector(4, n_, 2) -def MonsterStartTestarrayofstringVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestarrayofstringVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestarrayoftablesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -def MonsterStartTestnestedflatbufferVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestnestedflatbufferVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint8(e_) return b_.EndVector(v_.length) -def MonsterStartTestarrayofboolsVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestarrayofboolsVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependBool(e_) return b_.EndVector(v_.length) -def MonsterStartTestarrayofstring2Vector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestarrayofstring2Vector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers.builder, n_:int): b_.StartVector(8, n_, 4) -def MonsterStartFlexVector(b_:flatbuffers_builder, n_:int): +def MonsterStartFlexVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint8(e_) return b_.EndVector(v_.length) -def MonsterStartTest5Vector(b_:flatbuffers_builder, n_:int): +def MonsterStartTest5Vector(b_:flatbuffers.builder, n_:int): b_.StartVector(4, n_, 2) -def MonsterStartVectorOfLongsVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfLongsVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependInt64(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfDoublesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependFloat64(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfReferrablesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfReferrablesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint64(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint64(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint64(e_) return b_.EndVector(v_.length) -def MonsterStartVectorOfEnumsVector(b_:flatbuffers_builder, n_:int): +def MonsterStartVectorOfEnumsVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint8(e_) return b_.EndVector(v_.length) -def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers_builder, n_:int): +def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUint8(e_) return b_.EndVector(v_.length) -def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers_builder, n_:int): +def MonsterStartScalarKeySortedTablesVector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependUOffsetTRelative(e_) return b_.EndVector(v_.length) -class TypeAliases : flatbuffers_handle +class TypeAliases : flatbuffers.handle def i8() -> int: - return buf_.flatbuffers_field_int8(pos_, 4, 0) + return flatbuffers.field_int8(buf_, pos_, 4, 0) def u8() -> int: - return buf_.flatbuffers_field_uint8(pos_, 6, 0) + return flatbuffers.field_uint8(buf_, pos_, 6, 0) def i16() -> int: - return buf_.flatbuffers_field_int16(pos_, 8, 0) + return flatbuffers.field_int16(buf_, pos_, 8, 0) def u16() -> int: - return buf_.flatbuffers_field_uint16(pos_, 10, 0) + return flatbuffers.field_uint16(buf_, pos_, 10, 0) def i32() -> int: - return buf_.flatbuffers_field_int32(pos_, 12, 0) + return flatbuffers.field_int32(buf_, pos_, 12, 0) def u32() -> int: - return buf_.flatbuffers_field_uint32(pos_, 14, 0) + return flatbuffers.field_uint32(buf_, pos_, 14, 0) def i64() -> int: - return buf_.flatbuffers_field_int64(pos_, 16, 0) + return flatbuffers.field_int64(buf_, pos_, 16, 0) def u64() -> int: - return buf_.flatbuffers_field_uint64(pos_, 18, 0) + return flatbuffers.field_uint64(buf_, pos_, 18, 0) def f32() -> float: - return buf_.flatbuffers_field_float32(pos_, 20, 0.0) + return flatbuffers.field_float32(buf_, pos_, 20, 0.0) 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: - 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: - return buf_.flatbuffers_field_vector_len(pos_, 24) + return flatbuffers.field_vector_len(buf_, pos_, 24) 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: - 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(12) return this @@ -830,25 +830,25 @@ struct TypeAliasesBuilder: def add_f64(f64:float): b_.PrependFloat64Slot(9, f64, 0.0) return this - def add_v8(v8:flatbuffers_offset): + def add_v8(v8:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(10, v8) return this - def add_vf64(vf64:flatbuffers_offset): + def add_vf64(vf64:flatbuffers.offset): b_.PrependUOffsetTRelativeSlot(11, vf64) return this def end(): return b_.EndObject() -def TypeAliasesStartV8Vector(b_:flatbuffers_builder, n_:int): +def TypeAliasesStartV8Vector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependInt8(e_) return b_.EndVector(v_.length) -def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int): +def TypeAliasesStartVf64Vector(b_:flatbuffers.builder, n_:int): 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) reverse(v_) e_: b_.PrependFloat64(e_) return b_.EndVector(v_.length) diff --git a/tests/optional_scalars_generated.lobster b/tests/optional_scalars_generated.lobster index 16d9c56b8..f1d72d84d 100644 --- a/tests/optional_scalars_generated.lobster +++ b/tests/optional_scalars_generated.lobster @@ -10,84 +10,84 @@ enum OptionalByte: class ScalarStuff -class ScalarStuff : flatbuffers_handle +class ScalarStuff : flatbuffers.handle 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: - 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: - return buf_.flatbuffers_field_int8(pos_, 8, 42) + return flatbuffers.field_int8(buf_, pos_, 8, 42) 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: - 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: - return buf_.flatbuffers_field_uint8(pos_, 14, 42) + return flatbuffers.field_uint8(buf_, pos_, 14, 42) 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: - 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: - return buf_.flatbuffers_field_int16(pos_, 20, 42) + return flatbuffers.field_int16(buf_, pos_, 20, 42) 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: - 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: - return buf_.flatbuffers_field_uint16(pos_, 26, 42) + return flatbuffers.field_uint16(buf_, pos_, 26, 42) 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: - 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: - return buf_.flatbuffers_field_int32(pos_, 32, 42) + return flatbuffers.field_int32(buf_, pos_, 32, 42) 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: - 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: - return buf_.flatbuffers_field_uint32(pos_, 38, 42) + return flatbuffers.field_uint32(buf_, pos_, 38, 42) 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: - 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: - return buf_.flatbuffers_field_int64(pos_, 44, 42) + return flatbuffers.field_int64(buf_, pos_, 44, 42) 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: - 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: - return buf_.flatbuffers_field_uint64(pos_, 50, 42) + return flatbuffers.field_uint64(buf_, pos_, 50, 42) 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: - 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: - return buf_.flatbuffers_field_float32(pos_, 56, 42.0) + return flatbuffers.field_float32(buf_, pos_, 56, 42.0) 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: - 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: - return buf_.flatbuffers_field_float64(pos_, 62, 42.0) + return flatbuffers.field_float64(buf_, pos_, 62, 42.0) 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: - 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: - return bool(buf_.flatbuffers_field_int8(pos_, 68, 1)) + return bool(flatbuffers.field_int8(buf_, pos_, 68, 1)) 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: - 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: - 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: - b_:flatbuffers_builder + b_:flatbuffers.builder def start(): b_.StartObject(36) return this