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:
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);

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):
// 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)

484
tests/monster_test_generated.lobster
View File

@@ -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)

78
tests/optional_scalars_generated.lobster
View File

@@ -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