Skip to content

Commit d3e8cb6

Browse files
committedSep 17, 2023
Lobster namespace change
1 parent 0343396 commit d3e8cb6

5 files changed

+339
-334
lines changed
 

‎src/idl_gen_lobster.cpp

+24-22
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ class LobsterGenerator : public BaseGenerator {
3131
public:
3232
LobsterGenerator(const Parser &parser, const std::string &path,
3333
const std::string &file_name)
34-
: BaseGenerator(parser, path, file_name, "" /* not used */, "_",
34+
: BaseGenerator(parser, path, file_name, "" /* not used */, ".",
3535
"lobster") {
3636
static const char *const keywords[] = {
3737
"nil", "true", "false", "return", "struct", "class",
@@ -79,7 +79,7 @@ class LobsterGenerator : public BaseGenerator {
7979
if (IsBool(type.base_type)) return "bool";
8080
if (IsScalar(type.base_type) && type.enum_def)
8181
return NormalizedName(*type.enum_def);
82-
if (!IsScalar(type.base_type)) return "flatbuffers_offset";
82+
if (!IsScalar(type.base_type)) return "flatbuffers.offset";
8383
if (IsString(type)) return "string";
8484
return "int";
8585
}
@@ -119,15 +119,17 @@ class LobsterGenerator : public BaseGenerator {
119119
offsets + ")";
120120

121121
} else {
122-
auto defval = field.IsOptional() ? "0" : field.value.constant;
123-
acc = "buf_.flatbuffers_field_" + GenTypeName(field.value.type) +
124-
"(pos_, " + offsets + ", " + defval + ")";
122+
auto defval = field.IsOptional()
123+
? (IsFloat(field.value.type.base_type) ? "0.0" : "0")
124+
: field.value.constant;
125+
acc = "flatbuffers.field_" + GenTypeName(field.value.type) +
126+
"(buf_, pos_, " + offsets + ", " + defval + ")";
125127
if (IsBool(field.value.type.base_type)) acc = "bool(" + acc + ")";
126128
}
127129
if (field.value.type.enum_def)
128130
acc = NormalizedName(*field.value.type.enum_def) + "(" + acc + ")";
129131
if (field.IsOptional()) {
130-
acc += ", buf_.flatbuffers_field_present(pos_, " + offsets + ")";
132+
acc += ", flatbuffers.field_present(buf_, pos_, " + offsets + ")";
131133
code += def + "() -> " + LobsterType(field.value.type) +
132134
", bool:\n return " + acc + "\n";
133135
} else {
@@ -144,26 +146,26 @@ class LobsterGenerator : public BaseGenerator {
144146
code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n";
145147
} else {
146148
code += def + "() -> " + name + "?:\n ";
147-
code += std::string("let o = buf_.flatbuffers_field_") +
149+
code += std::string("let o = flatbuffers.field_") +
148150
(field.value.type.struct_def->fixed ? "struct" : "table") +
149-
"(pos_, " + offsets + ")\n return if o: " + name +
151+
"(buf_, pos_, " + offsets + ")\n return if o: " + name +
150152
" { buf_, o } else: nil\n";
151153
}
152154
break;
153155
}
154156
case BASE_TYPE_STRING:
155157
code += def +
156158
"() -> string:\n return "
157-
"buf_.flatbuffers_field_string(pos_, " +
159+
"flatbuffers.field_string(buf_, pos_, " +
158160
offsets + ")\n";
159161
break;
160162
case BASE_TYPE_VECTOR: {
161163
auto vectortype = field.value.type.VectorType();
162164
if (vectortype.base_type == BASE_TYPE_STRUCT) {
163-
auto start = "buf_.flatbuffers_field_vector(pos_, " + offsets +
165+
auto start = "flatbuffers.field_vector(buf_, pos_, " + offsets +
164166
") + i * " + NumToString(InlineSize(vectortype));
165167
if (!(vectortype.struct_def->fixed)) {
166-
start = "buf_.flatbuffers_indirect(" + start + ")";
168+
start = "flatbuffers.indirect(buf_, " + start + ")";
167169
}
168170
code += def + "(i:int) -> " +
169171
NamespacedName(*field.value.type.struct_def) +
@@ -173,13 +175,13 @@ class LobsterGenerator : public BaseGenerator {
173175
} else {
174176
if (IsString(vectortype)) {
175177
code += def + "(i:int) -> string:\n return ";
176-
code += "buf_.flatbuffers_string";
178+
code += "flatbuffers.string";
177179
} else {
178180
code += def + "(i:int) -> " + LobsterType(vectortype) +
179181
":\n return ";
180-
code += "buf_.read_" + GenTypeName(vectortype) + "_le";
182+
code += "read_" + GenTypeName(vectortype) + "_le";
181183
}
182-
code += "(buf_.flatbuffers_field_vector(pos_, " + offsets +
184+
code += "(buf_, buf_.flatbuffers.field_vector(pos_, " + offsets +
183185
") + i * " + NumToString(InlineSize(vectortype)) + ")\n";
184186
}
185187
break;
@@ -191,7 +193,7 @@ class LobsterGenerator : public BaseGenerator {
191193
if (ev.IsNonZero()) {
192194
code += def + "_as_" + ev.name + "():\n return " +
193195
NamespacedName(*ev.union_type.struct_def) +
194-
" { buf_, buf_.flatbuffers_field_table(pos_, " + offsets +
196+
" { buf_, flatbuffers.field_table(buf_, pos_, " + offsets +
195197
") }\n";
196198
}
197199
}
@@ -202,7 +204,7 @@ class LobsterGenerator : public BaseGenerator {
202204
if (IsVector(field.value.type)) {
203205
code += def +
204206
"_length() -> int:\n return "
205-
"buf_.flatbuffers_field_vector_len(pos_, " +
207+
"flatbuffers.field_vector_len(buf_, pos_, " +
206208
offsets + ")\n";
207209
}
208210
}
@@ -211,7 +213,7 @@ class LobsterGenerator : public BaseGenerator {
211213
void GenTableBuilders(const StructDef &struct_def, std::string *code_ptr) {
212214
std::string &code = *code_ptr;
213215
code += "struct " + NormalizedName(struct_def) +
214-
"Builder:\n b_:flatbuffers_builder\n";
216+
"Builder:\n b_:flatbuffers.builder\n";
215217
code += " def start():\n b_.StartObject(" +
216218
NumToString(struct_def.fields.vec.size()) +
217219
")\n return this\n";
@@ -236,7 +238,7 @@ class LobsterGenerator : public BaseGenerator {
236238
if (IsVector(field.value.type)) {
237239
code += "def " + NormalizedName(struct_def) + "Start" +
238240
ConvertCase(NormalizedName(field), Case::kUpperCamel) +
239-
"Vector(b_:flatbuffers_builder, n_:int):\n b_.StartVector(";
241+
"Vector(b_:flatbuffers.builder, n_:int):\n b_.StartVector(";
240242
auto vector_type = field.value.type.VectorType();
241243
auto alignment = InlineAlignment(vector_type);
242244
auto elem_size = InlineSize(vector_type);
@@ -246,7 +248,7 @@ class LobsterGenerator : public BaseGenerator {
246248
!vector_type.struct_def->fixed) {
247249
code += "def " + NormalizedName(struct_def) + "Create" +
248250
ConvertCase(NormalizedName(field), Case::kUpperCamel) +
249-
"Vector(b_:flatbuffers_builder, v_:[" +
251+
"Vector(b_:flatbuffers.builder, v_:[" +
250252
LobsterType(vector_type) + "]):\n b_.StartVector(" +
251253
NumToString(elem_size) + ", v_.length, " +
252254
NumToString(alignment) + ")\n reverse(v_) e_: b_.Prepend" +
@@ -271,7 +273,7 @@ class LobsterGenerator : public BaseGenerator {
271273
std::string &code = *code_ptr;
272274
CheckNameSpace(struct_def, &code);
273275
GenComment(struct_def.doc_comment, code_ptr, nullptr, "");
274-
code += "class " + NormalizedName(struct_def) + " : flatbuffers_handle\n";
276+
code += "class " + NormalizedName(struct_def) + " : flatbuffers.handle\n";
275277
for (auto it = struct_def.fields.vec.begin();
276278
it != struct_def.fields.vec.end(); ++it) {
277279
auto &field = **it;
@@ -284,7 +286,7 @@ class LobsterGenerator : public BaseGenerator {
284286
// the root type.
285287
code += "def GetRootAs" + NormalizedName(struct_def) +
286288
"(buf:string): return " + NormalizedName(struct_def) +
287-
" { buf, buf.flatbuffers_indirect(0) }\n\n";
289+
" { buf, flatbuffers.indirect(buf, 0) }\n\n";
288290
}
289291
if (struct_def.fixed) {
290292
// create a struct constructor function
@@ -360,7 +362,7 @@ class LobsterGenerator : public BaseGenerator {
360362
void GenStructBuilder(const StructDef &struct_def, std::string *code_ptr) {
361363
std::string &code = *code_ptr;
362364
code +=
363-
"def Create" + NormalizedName(struct_def) + "(b_:flatbuffers_builder";
365+
"def Create" + NormalizedName(struct_def) + "(b_:flatbuffers.builder";
364366
StructBuilderArgs(struct_def, "", code_ptr);
365367
code += "):\n";
366368
StructBuilderBody(struct_def, "", code_ptr);

‎tests/LobsterTest.bat

+3
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
..\Release\flatc.exe --lobster -I include_test monster_test.fbs
2+
..\Release\flatc.exe --lobster -I include_test optional_scalars.fbs
3+
..\..\lobster\bin\lobster.exe .\lobstertest.lobster

‎tests/lobstertest.lobster

+31-31
Original file line numberDiff line numberDiff line change
@@ -18,9 +18,9 @@ import optional_scalars_generated
1818

1919
def check_read_buffer(buf):
2020
// Check that the given buffer is evaluated correctly as the example Monster.
21-
assert flatbuffers_has_identifier(buf, "MONS")
21+
assert flatbuffers.has_identifier(buf, "MONS")
2222

23-
let monster = MyGame_Example_GetRootAsMonster(buf)
23+
let monster = MyGame.Example.GetRootAsMonster(buf)
2424

2525
assert monster.hp == 80
2626
assert monster.mana == 150
@@ -39,7 +39,7 @@ def check_read_buffer(buf):
3939
assert t.a == 5
4040
assert t.b == 6
4141

42-
assert monster.test_type == MyGame_Example_Any_Monster
42+
assert monster.test_type == MyGame.Example.Any_Monster
4343
assert monster.test_as_Monster.name == "Fred"
4444

4545
assert monster.inventory_length == 5
@@ -48,7 +48,7 @@ def check_read_buffer(buf):
4848
for(5) i:
4949
assert monster.vector_of_longs(i) == pow(10, i * 2)
5050

51-
assert equal([-1.7976931348623157e+308, 0, 1.7976931348623157e+308],
51+
assert equal([-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308],
5252
(map(monster.vector_of_doubles_length) i: monster.vector_of_doubles(i)))
5353

5454
assert monster.test4_length == 2
@@ -66,40 +66,40 @@ def check_read_buffer(buf):
6666

6767
def make_monster_from_generated_code():
6868
// Use generated code to build the example Monster.
69-
let b = flatbuffers_builder {}
69+
let b = flatbuffers.builder {}
7070

7171
let name = b.CreateString("MyMonster")
7272
let fred = b.CreateString("Fred")
7373

74-
let inv = b.MyGame_Example_MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ])
74+
let inv = b.MyGame.Example.MonsterCreateInventoryVector([ 0, 1, 2, 3, 4 ])
7575

76-
let mon2 = MyGame_Example_MonsterBuilder { b }
76+
let mon2 = MyGame.Example.MonsterBuilder { b }
7777
.start()
7878
.add_name(fred)
7979
.end()
8080

81-
b.MyGame_Example_MonsterStartTest4Vector(2)
82-
b.MyGame_Example_CreateTest(10, 20)
83-
b.MyGame_Example_CreateTest(30, 40)
81+
b.MyGame.Example.MonsterStartTest4Vector(2)
82+
b.MyGame.Example.CreateTest(10, 20)
83+
b.MyGame.Example.CreateTest(30, 40)
8484
let test4 = b.EndVector(2)
8585

86-
let test_array_of_string = b.MyGame_Example_MonsterCreateTestarrayofstringVector(
86+
let test_array_of_string = b.MyGame.Example.MonsterCreateTestarrayofstringVector(
8787
[ b.CreateString("test1"), b.CreateString("test2") ])
8888

89-
let vector_of_longs = b.MyGame_Example_MonsterCreateVectorOfLongsVector(
89+
let vector_of_longs = b.MyGame.Example.MonsterCreateVectorOfLongsVector(
9090
[ 1, 100, 10000, 1000000, 100000000 ])
9191

92-
let vector_of_doubles = b.MyGame_Example_MonsterCreateVectorOfDoublesVector(
93-
[ -1.7976931348623157e+308, 0, 1.7976931348623157e+308 ])
92+
let vector_of_doubles = b.MyGame.Example.MonsterCreateVectorOfDoublesVector(
93+
[ -1.7976931348623157e+308, 0.0, 1.7976931348623157e+308 ])
9494

95-
let mon = MyGame_Example_MonsterBuilder { b }
95+
let mon = MyGame.Example.MonsterBuilder { b }
9696
.start()
97-
.add_pos(b.MyGame_Example_CreateVec3(1.0, 2.0, 3.0, 3.0,
98-
MyGame_Example_Color_Green, 5, 6))
97+
.add_pos(b.MyGame.Example.CreateVec3(1.0, 2.0, 3.0, 3.0,
98+
MyGame.Example.Color_Green, 5, 6))
9999
.add_hp(80)
100100
.add_name(name)
101101
.add_inventory(inv)
102-
.add_test_type(MyGame_Example_Any_Monster)
102+
.add_test_type(MyGame.Example.Any_Monster)
103103
.add_test(mon2)
104104
.add_test4(test4)
105105
.add_testarrayofstring(test_array_of_string)
@@ -113,8 +113,8 @@ def make_monster_from_generated_code():
113113

114114
def test_optional_scalars():
115115
def build(add_fields):
116-
let b = flatbuffers_builder {}
117-
let ss = optional_scalars_ScalarStuffBuilder { b }.start()
116+
let b = flatbuffers.builder {}
117+
let ss = optional_scalars.ScalarStuffBuilder { b }.start()
118118
if add_fields:
119119
ss.add_just_i8(1)
120120
ss.add_maybe_i8(1)
@@ -125,13 +125,13 @@ def test_optional_scalars():
125125
ss.add_just_bool(true)
126126
ss.add_maybe_bool(true)
127127
ss.add_default_bool(true)
128-
ss.add_just_enum(optional_scalars_OptionalByte_Two)
129-
ss.add_maybe_enum(optional_scalars_OptionalByte_Two)
130-
ss.add_default_enum(optional_scalars_OptionalByte_Two)
128+
ss.add_just_enum(optional_scalars.OptionalByte_Two)
129+
ss.add_maybe_enum(optional_scalars.OptionalByte_Two)
130+
ss.add_default_enum(optional_scalars.OptionalByte_Two)
131131
b.Finish(ss.end(), "NULL")
132132
let buf = b.SizedCopy()
133-
assert flatbuffers_has_identifier(buf, "NULL")
134-
return optional_scalars_GetRootAsScalarStuff(buf)
133+
assert flatbuffers.has_identifier(buf, "NULL")
134+
return optional_scalars.GetRootAsScalarStuff(buf)
135135

136136
var root = build(true)
137137

@@ -147,9 +147,9 @@ def test_optional_scalars():
147147
var maybe_val_bool, maybe_present_bool = root.maybe_bool()
148148
assert maybe_val_bool == true and maybe_present_bool == true
149149

150-
assert root.just_enum() == optional_scalars_OptionalByte_Two and root.default_enum() == optional_scalars_OptionalByte_Two
150+
assert root.just_enum() == optional_scalars.OptionalByte_Two and root.default_enum() == optional_scalars.OptionalByte_Two
151151
var maybe_val_enum, maybe_present_enum = root.maybe_enum()
152-
assert maybe_val_enum == optional_scalars_OptionalByte_Two and maybe_present_enum == true
152+
assert maybe_val_enum == optional_scalars.OptionalByte_Two and maybe_present_enum == true
153153

154154
root = build(false)
155155

@@ -165,9 +165,9 @@ def test_optional_scalars():
165165
maybe_val_bool, maybe_present_bool = root.maybe_bool()
166166
assert maybe_val_bool == false and maybe_present_bool == false
167167

168-
assert root.just_enum() == optional_scalars_OptionalByte_None and root.default_enum() == optional_scalars_OptionalByte_One
168+
assert root.just_enum() == optional_scalars.OptionalByte_None and root.default_enum() == optional_scalars.OptionalByte_One
169169
maybe_val_enum, maybe_present_enum = root.maybe_enum()
170-
assert maybe_val_enum == optional_scalars_OptionalByte_None and maybe_present_enum == false
170+
assert maybe_val_enum == optional_scalars.OptionalByte_None and maybe_present_enum == false
171171

172172

173173
// Verify that the canonical flatbuffer file (produced by the C++ implementation)
@@ -188,10 +188,10 @@ let schema = read_file("monster_test.fbs")
188188
assert schema
189189
let includedirs = [ "include_test" ]
190190
// Convert binary to JSON:
191-
let json, err1 = flatbuffers_binary_to_json(schema, fb1, includedirs)
191+
let json, err1 = flatbuffers.binary_to_json(schema, fb1, includedirs)
192192
assert not err1
193193
// Parse JSON back to binary:
194-
let fb3, err2 = flatbuffers_json_to_binary(schema, json, includedirs)
194+
let fb3, err2 = flatbuffers.json_to_binary(schema, json, includedirs)
195195
assert not err2
196196
// Check the resulting binary again (full roundtrip test):
197197
check_read_buffer(fb3)

‎tests/monster_test_generated.lobster

+242-242
Large diffs are not rendered by default.

‎tests/optional_scalars_generated.lobster

+39-39
Original file line numberDiff line numberDiff line change
@@ -10,84 +10,84 @@ enum OptionalByte:
1010

1111
class ScalarStuff
1212

13-
class ScalarStuff : flatbuffers_handle
13+
class ScalarStuff : flatbuffers.handle
1414
def just_i8() -> int:
15-
return buf_.flatbuffers_field_int8(pos_, 4, 0)
15+
return flatbuffers.field_int8(buf_, pos_, 4, 0)
1616
def maybe_i8() -> int, bool:
17-
return buf_.flatbuffers_field_int8(pos_, 6, 0), buf_.flatbuffers_field_present(pos_, 6)
17+
return flatbuffers.field_int8(buf_, pos_, 6, 0), flatbuffers.field_present(buf_, pos_, 6)
1818
def default_i8() -> int:
19-
return buf_.flatbuffers_field_int8(pos_, 8, 42)
19+
return flatbuffers.field_int8(buf_, pos_, 8, 42)
2020
def just_u8() -> int:
21-
return buf_.flatbuffers_field_uint8(pos_, 10, 0)
21+
return flatbuffers.field_uint8(buf_, pos_, 10, 0)
2222
def maybe_u8() -> int, bool:
23-
return buf_.flatbuffers_field_uint8(pos_, 12, 0), buf_.flatbuffers_field_present(pos_, 12)
23+
return flatbuffers.field_uint8(buf_, pos_, 12, 0), flatbuffers.field_present(buf_, pos_, 12)
2424
def default_u8() -> int:
25-
return buf_.flatbuffers_field_uint8(pos_, 14, 42)
25+
return flatbuffers.field_uint8(buf_, pos_, 14, 42)
2626
def just_i16() -> int:
27-
return buf_.flatbuffers_field_int16(pos_, 16, 0)
27+
return flatbuffers.field_int16(buf_, pos_, 16, 0)
2828
def maybe_i16() -> int, bool:
29-
return buf_.flatbuffers_field_int16(pos_, 18, 0), buf_.flatbuffers_field_present(pos_, 18)
29+
return flatbuffers.field_int16(buf_, pos_, 18, 0), flatbuffers.field_present(buf_, pos_, 18)
3030
def default_i16() -> int:
31-
return buf_.flatbuffers_field_int16(pos_, 20, 42)
31+
return flatbuffers.field_int16(buf_, pos_, 20, 42)
3232
def just_u16() -> int:
33-
return buf_.flatbuffers_field_uint16(pos_, 22, 0)
33+
return flatbuffers.field_uint16(buf_, pos_, 22, 0)
3434
def maybe_u16() -> int, bool:
35-
return buf_.flatbuffers_field_uint16(pos_, 24, 0), buf_.flatbuffers_field_present(pos_, 24)
35+
return flatbuffers.field_uint16(buf_, pos_, 24, 0), flatbuffers.field_present(buf_, pos_, 24)
3636
def default_u16() -> int:
37-
return buf_.flatbuffers_field_uint16(pos_, 26, 42)
37+
return flatbuffers.field_uint16(buf_, pos_, 26, 42)
3838
def just_i32() -> int:
39-
return buf_.flatbuffers_field_int32(pos_, 28, 0)
39+
return flatbuffers.field_int32(buf_, pos_, 28, 0)
4040
def maybe_i32() -> int, bool:
41-
return buf_.flatbuffers_field_int32(pos_, 30, 0), buf_.flatbuffers_field_present(pos_, 30)
41+
return flatbuffers.field_int32(buf_, pos_, 30, 0), flatbuffers.field_present(buf_, pos_, 30)
4242
def default_i32() -> int:
43-
return buf_.flatbuffers_field_int32(pos_, 32, 42)
43+
return flatbuffers.field_int32(buf_, pos_, 32, 42)
4444
def just_u32() -> int:
45-
return buf_.flatbuffers_field_uint32(pos_, 34, 0)
45+
return flatbuffers.field_uint32(buf_, pos_, 34, 0)
4646
def maybe_u32() -> int, bool:
47-
return buf_.flatbuffers_field_uint32(pos_, 36, 0), buf_.flatbuffers_field_present(pos_, 36)
47+
return flatbuffers.field_uint32(buf_, pos_, 36, 0), flatbuffers.field_present(buf_, pos_, 36)
4848
def default_u32() -> int:
49-
return buf_.flatbuffers_field_uint32(pos_, 38, 42)
49+
return flatbuffers.field_uint32(buf_, pos_, 38, 42)
5050
def just_i64() -> int:
51-
return buf_.flatbuffers_field_int64(pos_, 40, 0)
51+
return flatbuffers.field_int64(buf_, pos_, 40, 0)
5252
def maybe_i64() -> int, bool:
53-
return buf_.flatbuffers_field_int64(pos_, 42, 0), buf_.flatbuffers_field_present(pos_, 42)
53+
return flatbuffers.field_int64(buf_, pos_, 42, 0), flatbuffers.field_present(buf_, pos_, 42)
5454
def default_i64() -> int:
55-
return buf_.flatbuffers_field_int64(pos_, 44, 42)
55+
return flatbuffers.field_int64(buf_, pos_, 44, 42)
5656
def just_u64() -> int:
57-
return buf_.flatbuffers_field_uint64(pos_, 46, 0)
57+
return flatbuffers.field_uint64(buf_, pos_, 46, 0)
5858
def maybe_u64() -> int, bool:
59-
return buf_.flatbuffers_field_uint64(pos_, 48, 0), buf_.flatbuffers_field_present(pos_, 48)
59+
return flatbuffers.field_uint64(buf_, pos_, 48, 0), flatbuffers.field_present(buf_, pos_, 48)
6060
def default_u64() -> int:
61-
return buf_.flatbuffers_field_uint64(pos_, 50, 42)
61+
return flatbuffers.field_uint64(buf_, pos_, 50, 42)
6262
def just_f32() -> float:
63-
return buf_.flatbuffers_field_float32(pos_, 52, 0.0)
63+
return flatbuffers.field_float32(buf_, pos_, 52, 0.0)
6464
def maybe_f32() -> float, bool:
65-
return buf_.flatbuffers_field_float32(pos_, 54, 0), buf_.flatbuffers_field_present(pos_, 54)
65+
return flatbuffers.field_float32(buf_, pos_, 54, 0.0), flatbuffers.field_present(buf_, pos_, 54)
6666
def default_f32() -> float:
67-
return buf_.flatbuffers_field_float32(pos_, 56, 42.0)
67+
return flatbuffers.field_float32(buf_, pos_, 56, 42.0)
6868
def just_f64() -> float:
69-
return buf_.flatbuffers_field_float64(pos_, 58, 0.0)
69+
return flatbuffers.field_float64(buf_, pos_, 58, 0.0)
7070
def maybe_f64() -> float, bool:
71-
return buf_.flatbuffers_field_float64(pos_, 60, 0), buf_.flatbuffers_field_present(pos_, 60)
71+
return flatbuffers.field_float64(buf_, pos_, 60, 0.0), flatbuffers.field_present(buf_, pos_, 60)
7272
def default_f64() -> float:
73-
return buf_.flatbuffers_field_float64(pos_, 62, 42.0)
73+
return flatbuffers.field_float64(buf_, pos_, 62, 42.0)
7474
def just_bool() -> bool:
75-
return bool(buf_.flatbuffers_field_int8(pos_, 64, 0))
75+
return bool(flatbuffers.field_int8(buf_, pos_, 64, 0))
7676
def maybe_bool() -> bool, bool:
77-
return bool(buf_.flatbuffers_field_int8(pos_, 66, 0)), buf_.flatbuffers_field_present(pos_, 66)
77+
return bool(flatbuffers.field_int8(buf_, pos_, 66, 0)), flatbuffers.field_present(buf_, pos_, 66)
7878
def default_bool() -> bool:
79-
return bool(buf_.flatbuffers_field_int8(pos_, 68, 1))
79+
return bool(flatbuffers.field_int8(buf_, pos_, 68, 1))
8080
def just_enum() -> OptionalByte:
81-
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 70, 0))
81+
return OptionalByte(flatbuffers.field_int8(buf_, pos_, 70, 0))
8282
def maybe_enum() -> OptionalByte, bool:
83-
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 72, 0)), buf_.flatbuffers_field_present(pos_, 72)
83+
return OptionalByte(flatbuffers.field_int8(buf_, pos_, 72, 0)), flatbuffers.field_present(buf_, pos_, 72)
8484
def default_enum() -> OptionalByte:
85-
return OptionalByte(buf_.flatbuffers_field_int8(pos_, 74, 1))
85+
return OptionalByte(flatbuffers.field_int8(buf_, pos_, 74, 1))
8686

87-
def GetRootAsScalarStuff(buf:string): return ScalarStuff { buf, buf.flatbuffers_indirect(0) }
87+
def GetRootAsScalarStuff(buf:string): return ScalarStuff { buf, flatbuffers.indirect(buf, 0) }
8888

8989
struct ScalarStuffBuilder:
90-
b_:flatbuffers_builder
90+
b_:flatbuffers.builder
9191
def start():
9292
b_.StartObject(36)
9393
return this

0 commit comments

Comments
 (0)
Please sign in to comment.