1// automatically generated by the FlatBuffers compiler, do not modify
2// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
3
4library my_game.example;
5
6import 'dart:typed_data' show Uint8List;
7import 'package:flat_buffers/flat_buffers.dart' as fb;
8
9import './monster_test_my_game_generated.dart' as my_game;
10import './monster_test_my_game.example2_generated.dart' as my_game_example2;
11
12import './include_test1_generated.dart';
13
14/// Composite components of Monster color.
15class Color {
16 final int value;
17 const Color._(this.value);
18
19 factory Color.fromValue(int value) {
20 final result = values[value];
21 if (result == null) {
22 if (value == 0) {
23 return Color._(0);
24 } else {
25 throw StateError('Invalid value $value for bit flag enum Color');
26 }
27 }
28 return result;
29 }
30
31 static Color? _createOrNull(int? value) =>
32 value == null ? null : Color.fromValue(value);
33
34 static bool containsValue(int value) => values.containsKey(value);
35
36 static const Color Red = Color._(1);
37
38 /// \brief color Green
39 /// Green is bit_flag with value (1u << 1)
40 static const Color Green = Color._(2);
41
42 /// \brief color Blue (1u << 3)
43 static const Color Blue = Color._(8);
44 static const Map<int, Color> values = {
45 1: Red,
46 2: Green,
47 8: Blue};
48
49 static const fb.Reader<Color> reader = _ColorReader();
50
51 @override
52 String toString() {
53 return 'Color{value: $value}';
54 }
55}
56
57class _ColorReader extends fb.Reader<Color> {
58 const _ColorReader();
59
60 @override
61 int get size => 1;
62
63 @override
64 Color read(fb.BufferContext bc, int offset) =>
65 Color.fromValue(const fb.Uint8Reader().read(bc, offset));
66}
67
68class Race {
69 final int value;
70 const Race._(this.value);
71
72 factory Race.fromValue(int value) {
73 final result = values[value];
74 if (result == null) {
75 throw StateError('Invalid value $value for bit flag enum Race');
76 }
77 return result;
78 }
79
80 static Race? _createOrNull(int? value) =>
81 value == null ? null : Race.fromValue(value);
82
83 static const int minValue = -1;
84 static const int maxValue = 2;
85 static bool containsValue(int value) => values.containsKey(value);
86
87 static const Race None = Race._(-1);
88 static const Race Human = Race._(0);
89 static const Race Dwarf = Race._(1);
90 static const Race Elf = Race._(2);
91 static const Map<int, Race> values = {
92 -1: None,
93 0: Human,
94 1: Dwarf,
95 2: Elf};
96
97 static const fb.Reader<Race> reader = _RaceReader();
98
99 @override
100 String toString() {
101 return 'Race{value: $value}';
102 }
103}
104
105class _RaceReader extends fb.Reader<Race> {
106 const _RaceReader();
107
108 @override
109 int get size => 1;
110
111 @override
112 Race read(fb.BufferContext bc, int offset) =>
113 Race.fromValue(const fb.Int8Reader().read(bc, offset));
114}
115
116class LongEnum {
117 final int value;
118 const LongEnum._(this.value);
119
120 factory LongEnum.fromValue(int value) {
121 final result = values[value];
122 if (result == null) {
123 if (value == 0) {
124 return LongEnum._(0);
125 } else {
126 throw StateError('Invalid value $value for bit flag enum LongEnum');
127 }
128 }
129 return result;
130 }
131
132 static LongEnum? _createOrNull(int? value) =>
133 value == null ? null : LongEnum.fromValue(value);
134
135 static bool containsValue(int value) => values.containsKey(value);
136
137 static const LongEnum LongOne = LongEnum._(2);
138 static const LongEnum LongTwo = LongEnum._(4);
139 static const LongEnum LongBig = LongEnum._(1099511627776);
140 static const Map<int, LongEnum> values = {
141 2: LongOne,
142 4: LongTwo,
143 1099511627776: LongBig};
144
145 static const fb.Reader<LongEnum> reader = _LongEnumReader();
146
147 @override
148 String toString() {
149 return 'LongEnum{value: $value}';
150 }
151}
152
153class _LongEnumReader extends fb.Reader<LongEnum> {
154 const _LongEnumReader();
155
156 @override
157 int get size => 8;
158
159 @override
160 LongEnum read(fb.BufferContext bc, int offset) =>
161 LongEnum.fromValue(const fb.Uint64Reader().read(bc, offset));
162}
163
164class AnyTypeId {
165 final int value;
166 const AnyTypeId._(this.value);
167
168 factory AnyTypeId.fromValue(int value) {
169 final result = values[value];
170 if (result == null) {
171 throw StateError('Invalid value $value for bit flag enum AnyTypeId');
172 }
173 return result;
174 }
175
176 static AnyTypeId? _createOrNull(int? value) =>
177 value == null ? null : AnyTypeId.fromValue(value);
178
179 static const int minValue = 0;
180 static const int maxValue = 3;
181 static bool containsValue(int value) => values.containsKey(value);
182
183 static const AnyTypeId NONE = AnyTypeId._(0);
184 static const AnyTypeId Monster = AnyTypeId._(1);
185 static const AnyTypeId TestSimpleTableWithEnum = AnyTypeId._(2);
186 static const AnyTypeId MyGame_Example2_Monster = AnyTypeId._(3);
187 static const Map<int, AnyTypeId> values = {
188 0: NONE,
189 1: Monster,
190 2: TestSimpleTableWithEnum,
191 3: MyGame_Example2_Monster};
192
193 static const fb.Reader<AnyTypeId> reader = _AnyTypeIdReader();
194
195 @override
196 String toString() {
197 return 'AnyTypeId{value: $value}';
198 }
199}
200
201class _AnyTypeIdReader extends fb.Reader<AnyTypeId> {
202 const _AnyTypeIdReader();
203
204 @override
205 int get size => 1;
206
207 @override
208 AnyTypeId read(fb.BufferContext bc, int offset) =>
209 AnyTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
210}
211
212class AnyUniqueAliasesTypeId {
213 final int value;
214 const AnyUniqueAliasesTypeId._(this.value);
215
216 factory AnyUniqueAliasesTypeId.fromValue(int value) {
217 final result = values[value];
218 if (result == null) {
219 throw StateError('Invalid value $value for bit flag enum AnyUniqueAliasesTypeId');
220 }
221 return result;
222 }
223
224 static AnyUniqueAliasesTypeId? _createOrNull(int? value) =>
225 value == null ? null : AnyUniqueAliasesTypeId.fromValue(value);
226
227 static const int minValue = 0;
228 static const int maxValue = 3;
229 static bool containsValue(int value) => values.containsKey(value);
230
231 static const AnyUniqueAliasesTypeId NONE = AnyUniqueAliasesTypeId._(0);
232 static const AnyUniqueAliasesTypeId M = AnyUniqueAliasesTypeId._(1);
233 static const AnyUniqueAliasesTypeId TS = AnyUniqueAliasesTypeId._(2);
234 static const AnyUniqueAliasesTypeId M2 = AnyUniqueAliasesTypeId._(3);
235 static const Map<int, AnyUniqueAliasesTypeId> values = {
236 0: NONE,
237 1: M,
238 2: TS,
239 3: M2};
240
241 static const fb.Reader<AnyUniqueAliasesTypeId> reader = _AnyUniqueAliasesTypeIdReader();
242
243 @override
244 String toString() {
245 return 'AnyUniqueAliasesTypeId{value: $value}';
246 }
247}
248
249class _AnyUniqueAliasesTypeIdReader extends fb.Reader<AnyUniqueAliasesTypeId> {
250 const _AnyUniqueAliasesTypeIdReader();
251
252 @override
253 int get size => 1;
254
255 @override
256 AnyUniqueAliasesTypeId read(fb.BufferContext bc, int offset) =>
257 AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
258}
259
260class AnyAmbiguousAliasesTypeId {
261 final int value;
262 const AnyAmbiguousAliasesTypeId._(this.value);
263
264 factory AnyAmbiguousAliasesTypeId.fromValue(int value) {
265 final result = values[value];
266 if (result == null) {
267 throw StateError('Invalid value $value for bit flag enum AnyAmbiguousAliasesTypeId');
268 }
269 return result;
270 }
271
272 static AnyAmbiguousAliasesTypeId? _createOrNull(int? value) =>
273 value == null ? null : AnyAmbiguousAliasesTypeId.fromValue(value);
274
275 static const int minValue = 0;
276 static const int maxValue = 3;
277 static bool containsValue(int value) => values.containsKey(value);
278
279 static const AnyAmbiguousAliasesTypeId NONE = AnyAmbiguousAliasesTypeId._(0);
280 static const AnyAmbiguousAliasesTypeId M1 = AnyAmbiguousAliasesTypeId._(1);
281 static const AnyAmbiguousAliasesTypeId M2 = AnyAmbiguousAliasesTypeId._(2);
282 static const AnyAmbiguousAliasesTypeId M3 = AnyAmbiguousAliasesTypeId._(3);
283 static const Map<int, AnyAmbiguousAliasesTypeId> values = {
284 0: NONE,
285 1: M1,
286 2: M2,
287 3: M3};
288
289 static const fb.Reader<AnyAmbiguousAliasesTypeId> reader = _AnyAmbiguousAliasesTypeIdReader();
290
291 @override
292 String toString() {
293 return 'AnyAmbiguousAliasesTypeId{value: $value}';
294 }
295}
296
297class _AnyAmbiguousAliasesTypeIdReader extends fb.Reader<AnyAmbiguousAliasesTypeId> {
298 const _AnyAmbiguousAliasesTypeIdReader();
299
300 @override
301 int get size => 1;
302
303 @override
304 AnyAmbiguousAliasesTypeId read(fb.BufferContext bc, int offset) =>
305 AnyAmbiguousAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
306}
307
308class Test {
309 Test._(this._bc, this._bcOffset);
310
311 static const fb.Reader<Test> reader = _TestReader();
312
313 final fb.BufferContext _bc;
314 final int _bcOffset;
315
316 int get a => const fb.Int16Reader().read(_bc, _bcOffset + 0);
317 int get b => const fb.Int8Reader().read(_bc, _bcOffset + 2);
318
319 @override
320 String toString() {
321 return 'Test{a: ${a}, b: ${b}}';
322 }
323
324 TestT unpack() => TestT(
325 a: a,
326 b: b);
327
328 static int pack(fb.Builder fbBuilder, TestT? object) {
329 if (object == null) return 0;
330 return object.pack(fbBuilder);
331 }
332}
333
334class TestT implements fb.Packable {
335 int a;
336 int b;
337
338 TestT({
339 required this.a,
340 required this.b});
341
342 @override
343 int pack(fb.Builder fbBuilder) {
344 fbBuilder.pad(1);
345 fbBuilder.putInt8(b);
346 fbBuilder.putInt16(a);
347 return fbBuilder.offset;
348 }
349
350 @override
351 String toString() {
352 return 'TestT{a: ${a}, b: ${b}}';
353 }
354}
355
356class _TestReader extends fb.StructReader<Test> {
357 const _TestReader();
358
359 @override
360 int get size => 4;
361
362 @override
363 Test createObject(fb.BufferContext bc, int offset) =>
364 Test._(bc, offset);
365}
366
367class TestBuilder {
368 TestBuilder(this.fbBuilder);
369
370 final fb.Builder fbBuilder;
371
372 int finish(int a, int b) {
373 fbBuilder.pad(1);
374 fbBuilder.putInt8(b);
375 fbBuilder.putInt16(a);
376 return fbBuilder.offset;
377 }
378
379}
380
381class TestObjectBuilder extends fb.ObjectBuilder {
382 final int _a;
383 final int _b;
384
385 TestObjectBuilder({
386 required int a,
387 required int b,
388 })
389 : _a = a,
390 _b = b;
391
392 /// Finish building, and store into the [fbBuilder].
393 @override
394 int finish(fb.Builder fbBuilder) {
395 fbBuilder.pad(1);
396 fbBuilder.putInt8(_b);
397 fbBuilder.putInt16(_a);
398 return fbBuilder.offset;
399 }
400
401 /// Convenience method to serialize to byte list.
402 @override
403 Uint8List toBytes([String? fileIdentifier]) {
404 final fbBuilder = fb.Builder(deduplicateTables: false);
405 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
406 return fbBuilder.buffer;
407 }
408}
409class TestSimpleTableWithEnum {
410 TestSimpleTableWithEnum._(this._bc, this._bcOffset);
411 factory TestSimpleTableWithEnum(List<int> bytes) {
412 final rootRef = fb.BufferContext.fromBytes(bytes);
413 return reader.read(rootRef, 0);
414 }
415
416 static const fb.Reader<TestSimpleTableWithEnum> reader = _TestSimpleTableWithEnumReader();
417
418 final fb.BufferContext _bc;
419 final int _bcOffset;
420
421 Color get color => Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 4, 2));
422
423 @override
424 String toString() {
425 return 'TestSimpleTableWithEnum{color: ${color}}';
426 }
427
428 TestSimpleTableWithEnumT unpack() => TestSimpleTableWithEnumT(
429 color: color);
430
431 static int pack(fb.Builder fbBuilder, TestSimpleTableWithEnumT? object) {
432 if (object == null) return 0;
433 return object.pack(fbBuilder);
434 }
435}
436
437class TestSimpleTableWithEnumT implements fb.Packable {
438 Color color;
439
440 TestSimpleTableWithEnumT({
441 this.color = Color.Green});
442
443 @override
444 int pack(fb.Builder fbBuilder) {
445 fbBuilder.startTable(1);
446 fbBuilder.addUint8(0, color.value);
447 return fbBuilder.endTable();
448 }
449
450 @override
451 String toString() {
452 return 'TestSimpleTableWithEnumT{color: ${color}}';
453 }
454}
455
456class _TestSimpleTableWithEnumReader extends fb.TableReader<TestSimpleTableWithEnum> {
457 const _TestSimpleTableWithEnumReader();
458
459 @override
460 TestSimpleTableWithEnum createObject(fb.BufferContext bc, int offset) =>
461 TestSimpleTableWithEnum._(bc, offset);
462}
463
464class TestSimpleTableWithEnumBuilder {
465 TestSimpleTableWithEnumBuilder(this.fbBuilder);
466
467 final fb.Builder fbBuilder;
468
469 void begin() {
470 fbBuilder.startTable(1);
471 }
472
473 int addColor(Color? color) {
474 fbBuilder.addUint8(0, color?.value);
475 return fbBuilder.offset;
476 }
477
478 int finish() {
479 return fbBuilder.endTable();
480 }
481}
482
483class TestSimpleTableWithEnumObjectBuilder extends fb.ObjectBuilder {
484 final Color? _color;
485
486 TestSimpleTableWithEnumObjectBuilder({
487 Color? color,
488 })
489 : _color = color;
490
491 /// Finish building, and store into the [fbBuilder].
492 @override
493 int finish(fb.Builder fbBuilder) {
494 fbBuilder.startTable(1);
495 fbBuilder.addUint8(0, _color?.value);
496 return fbBuilder.endTable();
497 }
498
499 /// Convenience method to serialize to byte list.
500 @override
501 Uint8List toBytes([String? fileIdentifier]) {
502 final fbBuilder = fb.Builder(deduplicateTables: false);
503 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
504 return fbBuilder.buffer;
505 }
506}
507class Vec3 {
508 Vec3._(this._bc, this._bcOffset);
509
510 static const fb.Reader<Vec3> reader = _Vec3Reader();
511
512 final fb.BufferContext _bc;
513 final int _bcOffset;
514
515 double get x => const fb.Float32Reader().read(_bc, _bcOffset + 0);
516 double get y => const fb.Float32Reader().read(_bc, _bcOffset + 4);
517 double get z => const fb.Float32Reader().read(_bc, _bcOffset + 8);
518 double get test1 => const fb.Float64Reader().read(_bc, _bcOffset + 16);
519 Color get test2 => Color.fromValue(const fb.Uint8Reader().read(_bc, _bcOffset + 24));
520 Test get test3 => Test.reader.read(_bc, _bcOffset + 26);
521
522 @override
523 String toString() {
524 return 'Vec3{x: ${x}, y: ${y}, z: ${z}, test1: ${test1}, test2: ${test2}, test3: ${test3}}';
525 }
526
527 Vec3T unpack() => Vec3T(
528 x: x,
529 y: y,
530 z: z,
531 test1: test1,
532 test2: test2,
533 test3: test3.unpack());
534
535 static int pack(fb.Builder fbBuilder, Vec3T? object) {
536 if (object == null) return 0;
537 return object.pack(fbBuilder);
538 }
539}
540
541class Vec3T implements fb.Packable {
542 double x;
543 double y;
544 double z;
545 double test1;
546 Color test2;
547 TestT test3;
548
549 Vec3T({
550 required this.x,
551 required this.y,
552 required this.z,
553 required this.test1,
554 required this.test2,
555 required this.test3});
556
557 @override
558 int pack(fb.Builder fbBuilder) {
559 fbBuilder.pad(2);
560 test3.pack(fbBuilder);
561 fbBuilder.pad(1);
562 fbBuilder.putUint8(test2.value);
563 fbBuilder.putFloat64(test1);
564 fbBuilder.pad(4);
565 fbBuilder.putFloat32(z);
566 fbBuilder.putFloat32(y);
567 fbBuilder.putFloat32(x);
568 return fbBuilder.offset;
569 }
570
571 @override
572 String toString() {
573 return 'Vec3T{x: ${x}, y: ${y}, z: ${z}, test1: ${test1}, test2: ${test2}, test3: ${test3}}';
574 }
575}
576
577class _Vec3Reader extends fb.StructReader<Vec3> {
578 const _Vec3Reader();
579
580 @override
581 int get size => 32;
582
583 @override
584 Vec3 createObject(fb.BufferContext bc, int offset) =>
585 Vec3._(bc, offset);
586}
587
588class Vec3Builder {
589 Vec3Builder(this.fbBuilder);
590
591 final fb.Builder fbBuilder;
592
593 int finish(double x, double y, double z, double test1, Color test2, fb.StructBuilder test3) {
594 fbBuilder.pad(2);
595 test3();
596 fbBuilder.pad(1);
597 fbBuilder.putUint8(test2.value);
598 fbBuilder.putFloat64(test1);
599 fbBuilder.pad(4);
600 fbBuilder.putFloat32(z);
601 fbBuilder.putFloat32(y);
602 fbBuilder.putFloat32(x);
603 return fbBuilder.offset;
604 }
605
606}
607
608class Vec3ObjectBuilder extends fb.ObjectBuilder {
609 final double _x;
610 final double _y;
611 final double _z;
612 final double _test1;
613 final Color _test2;
614 final TestObjectBuilder _test3;
615
616 Vec3ObjectBuilder({
617 required double x,
618 required double y,
619 required double z,
620 required double test1,
621 required Color test2,
622 required TestObjectBuilder test3,
623 })
624 : _x = x,
625 _y = y,
626 _z = z,
627 _test1 = test1,
628 _test2 = test2,
629 _test3 = test3;
630
631 /// Finish building, and store into the [fbBuilder].
632 @override
633 int finish(fb.Builder fbBuilder) {
634 fbBuilder.pad(2);
635 _test3.finish(fbBuilder);
636 fbBuilder.pad(1);
637 fbBuilder.putUint8(_test2.value);
638 fbBuilder.putFloat64(_test1);
639 fbBuilder.pad(4);
640 fbBuilder.putFloat32(_z);
641 fbBuilder.putFloat32(_y);
642 fbBuilder.putFloat32(_x);
643 return fbBuilder.offset;
644 }
645
646 /// Convenience method to serialize to byte list.
647 @override
648 Uint8List toBytes([String? fileIdentifier]) {
649 final fbBuilder = fb.Builder(deduplicateTables: false);
650 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
651 return fbBuilder.buffer;
652 }
653}
654class Ability {
655 Ability._(this._bc, this._bcOffset);
656
657 static const fb.Reader<Ability> reader = _AbilityReader();
658
659 final fb.BufferContext _bc;
660 final int _bcOffset;
661
662 int get id => const fb.Uint32Reader().read(_bc, _bcOffset + 0);
663 int get distance => const fb.Uint32Reader().read(_bc, _bcOffset + 4);
664
665 @override
666 String toString() {
667 return 'Ability{id: ${id}, distance: ${distance}}';
668 }
669
670 AbilityT unpack() => AbilityT(
671 id: id,
672 distance: distance);
673
674 static int pack(fb.Builder fbBuilder, AbilityT? object) {
675 if (object == null) return 0;
676 return object.pack(fbBuilder);
677 }
678}
679
680class AbilityT implements fb.Packable {
681 int id;
682 int distance;
683
684 AbilityT({
685 required this.id,
686 required this.distance});
687
688 @override
689 int pack(fb.Builder fbBuilder) {
690 fbBuilder.putUint32(distance);
691 fbBuilder.putUint32(id);
692 return fbBuilder.offset;
693 }
694
695 @override
696 String toString() {
697 return 'AbilityT{id: ${id}, distance: ${distance}}';
698 }
699}
700
701class _AbilityReader extends fb.StructReader<Ability> {
702 const _AbilityReader();
703
704 @override
705 int get size => 8;
706
707 @override
708 Ability createObject(fb.BufferContext bc, int offset) =>
709 Ability._(bc, offset);
710}
711
712class AbilityBuilder {
713 AbilityBuilder(this.fbBuilder);
714
715 final fb.Builder fbBuilder;
716
717 int finish(int id, int distance) {
718 fbBuilder.putUint32(distance);
719 fbBuilder.putUint32(id);
720 return fbBuilder.offset;
721 }
722
723}
724
725class AbilityObjectBuilder extends fb.ObjectBuilder {
726 final int _id;
727 final int _distance;
728
729 AbilityObjectBuilder({
730 required int id,
731 required int distance,
732 })
733 : _id = id,
734 _distance = distance;
735
736 /// Finish building, and store into the [fbBuilder].
737 @override
738 int finish(fb.Builder fbBuilder) {
739 fbBuilder.putUint32(_distance);
740 fbBuilder.putUint32(_id);
741 return fbBuilder.offset;
742 }
743
744 /// Convenience method to serialize to byte list.
745 @override
746 Uint8List toBytes([String? fileIdentifier]) {
747 final fbBuilder = fb.Builder(deduplicateTables: false);
748 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
749 return fbBuilder.buffer;
750 }
751}
752class StructOfStructs {
753 StructOfStructs._(this._bc, this._bcOffset);
754
755 static const fb.Reader<StructOfStructs> reader = _StructOfStructsReader();
756
757 final fb.BufferContext _bc;
758 final int _bcOffset;
759
760 Ability get a => Ability.reader.read(_bc, _bcOffset + 0);
761 Test get b => Test.reader.read(_bc, _bcOffset + 8);
762 Ability get c => Ability.reader.read(_bc, _bcOffset + 12);
763
764 @override
765 String toString() {
766 return 'StructOfStructs{a: ${a}, b: ${b}, c: ${c}}';
767 }
768
769 StructOfStructsT unpack() => StructOfStructsT(
770 a: a.unpack(),
771 b: b.unpack(),
772 c: c.unpack());
773
774 static int pack(fb.Builder fbBuilder, StructOfStructsT? object) {
775 if (object == null) return 0;
776 return object.pack(fbBuilder);
777 }
778}
779
780class StructOfStructsT implements fb.Packable {
781 AbilityT a;
782 TestT b;
783 AbilityT c;
784
785 StructOfStructsT({
786 required this.a,
787 required this.b,
788 required this.c});
789
790 @override
791 int pack(fb.Builder fbBuilder) {
792 c.pack(fbBuilder);
793 b.pack(fbBuilder);
794 a.pack(fbBuilder);
795 return fbBuilder.offset;
796 }
797
798 @override
799 String toString() {
800 return 'StructOfStructsT{a: ${a}, b: ${b}, c: ${c}}';
801 }
802}
803
804class _StructOfStructsReader extends fb.StructReader<StructOfStructs> {
805 const _StructOfStructsReader();
806
807 @override
808 int get size => 20;
809
810 @override
811 StructOfStructs createObject(fb.BufferContext bc, int offset) =>
812 StructOfStructs._(bc, offset);
813}
814
815class StructOfStructsBuilder {
816 StructOfStructsBuilder(this.fbBuilder);
817
818 final fb.Builder fbBuilder;
819
820 int finish(fb.StructBuilder a, fb.StructBuilder b, fb.StructBuilder c) {
821 c();
822 b();
823 a();
824 return fbBuilder.offset;
825 }
826
827}
828
829class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
830 final AbilityObjectBuilder _a;
831 final TestObjectBuilder _b;
832 final AbilityObjectBuilder _c;
833
834 StructOfStructsObjectBuilder({
835 required AbilityObjectBuilder a,
836 required TestObjectBuilder b,
837 required AbilityObjectBuilder c,
838 })
839 : _a = a,
840 _b = b,
841 _c = c;
842
843 /// Finish building, and store into the [fbBuilder].
844 @override
845 int finish(fb.Builder fbBuilder) {
846 _c.finish(fbBuilder);
847 _b.finish(fbBuilder);
848 _a.finish(fbBuilder);
849 return fbBuilder.offset;
850 }
851
852 /// Convenience method to serialize to byte list.
853 @override
854 Uint8List toBytes([String? fileIdentifier]) {
855 final fbBuilder = fb.Builder(deduplicateTables: false);
856 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
857 return fbBuilder.buffer;
858 }
859}
860class StructOfStructsOfStructs {
861 StructOfStructsOfStructs._(this._bc, this._bcOffset);
862
863 static const fb.Reader<StructOfStructsOfStructs> reader = _StructOfStructsOfStructsReader();
864
865 final fb.BufferContext _bc;
866 final int _bcOffset;
867
868 StructOfStructs get a => StructOfStructs.reader.read(_bc, _bcOffset + 0);
869
870 @override
871 String toString() {
872 return 'StructOfStructsOfStructs{a: ${a}}';
873 }
874
875 StructOfStructsOfStructsT unpack() => StructOfStructsOfStructsT(
876 a: a.unpack());
877
878 static int pack(fb.Builder fbBuilder, StructOfStructsOfStructsT? object) {
879 if (object == null) return 0;
880 return object.pack(fbBuilder);
881 }
882}
883
884class StructOfStructsOfStructsT implements fb.Packable {
885 StructOfStructsT a;
886
887 StructOfStructsOfStructsT({
888 required this.a});
889
890 @override
891 int pack(fb.Builder fbBuilder) {
892 a.pack(fbBuilder);
893 return fbBuilder.offset;
894 }
895
896 @override
897 String toString() {
898 return 'StructOfStructsOfStructsT{a: ${a}}';
899 }
900}
901
902class _StructOfStructsOfStructsReader extends fb.StructReader<StructOfStructsOfStructs> {
903 const _StructOfStructsOfStructsReader();
904
905 @override
906 int get size => 20;
907
908 @override
909 StructOfStructsOfStructs createObject(fb.BufferContext bc, int offset) =>
910 StructOfStructsOfStructs._(bc, offset);
911}
912
913class StructOfStructsOfStructsBuilder {
914 StructOfStructsOfStructsBuilder(this.fbBuilder);
915
916 final fb.Builder fbBuilder;
917
918 int finish(fb.StructBuilder a) {
919 a();
920 return fbBuilder.offset;
921 }
922
923}
924
925class StructOfStructsOfStructsObjectBuilder extends fb.ObjectBuilder {
926 final StructOfStructsObjectBuilder _a;
927
928 StructOfStructsOfStructsObjectBuilder({
929 required StructOfStructsObjectBuilder a,
930 })
931 : _a = a;
932
933 /// Finish building, and store into the [fbBuilder].
934 @override
935 int finish(fb.Builder fbBuilder) {
936 _a.finish(fbBuilder);
937 return fbBuilder.offset;
938 }
939
940 /// Convenience method to serialize to byte list.
941 @override
942 Uint8List toBytes([String? fileIdentifier]) {
943 final fbBuilder = fb.Builder(deduplicateTables: false);
944 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
945 return fbBuilder.buffer;
946 }
947}
948class Stat {
949 Stat._(this._bc, this._bcOffset);
950 factory Stat(List<int> bytes) {
951 final rootRef = fb.BufferContext.fromBytes(bytes);
952 return reader.read(rootRef, 0);
953 }
954
955 static const fb.Reader<Stat> reader = _StatReader();
956
957 final fb.BufferContext _bc;
958 final int _bcOffset;
959
960 String? get id => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
961 int get val => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 6, 0);
962 int get count => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 8, 0);
963
964 @override
965 String toString() {
966 return 'Stat{id: ${id}, val: ${val}, count: ${count}}';
967 }
968
969 StatT unpack() => StatT(
970 id: id,
971 val: val,
972 count: count);
973
974 static int pack(fb.Builder fbBuilder, StatT? object) {
975 if (object == null) return 0;
976 return object.pack(fbBuilder);
977 }
978}
979
980class StatT implements fb.Packable {
981 String? id;
982 int val;
983 int count;
984
985 StatT({
986 this.id,
987 this.val = 0,
988 this.count = 0});
989
990 @override
991 int pack(fb.Builder fbBuilder) {
992 final int? idOffset = id == null ? null
993 : fbBuilder.writeString(id!);
994 fbBuilder.startTable(3);
995 fbBuilder.addOffset(0, idOffset);
996 fbBuilder.addInt64(1, val);
997 fbBuilder.addUint16(2, count);
998 return fbBuilder.endTable();
999 }
1000
1001 @override
1002 String toString() {
1003 return 'StatT{id: ${id}, val: ${val}, count: ${count}}';
1004 }
1005}
1006
1007class _StatReader extends fb.TableReader<Stat> {
1008 const _StatReader();
1009
1010 @override
1011 Stat createObject(fb.BufferContext bc, int offset) =>
1012 Stat._(bc, offset);
1013}
1014
1015class StatBuilder {
1016 StatBuilder(this.fbBuilder);
1017
1018 final fb.Builder fbBuilder;
1019
1020 void begin() {
1021 fbBuilder.startTable(3);
1022 }
1023
1024 int addIdOffset(int? offset) {
1025 fbBuilder.addOffset(0, offset);
1026 return fbBuilder.offset;
1027 }
1028 int addVal(int? val) {
1029 fbBuilder.addInt64(1, val);
1030 return fbBuilder.offset;
1031 }
1032 int addCount(int? count) {
1033 fbBuilder.addUint16(2, count);
1034 return fbBuilder.offset;
1035 }
1036
1037 int finish() {
1038 return fbBuilder.endTable();
1039 }
1040}
1041
1042class StatObjectBuilder extends fb.ObjectBuilder {
1043 final String? _id;
1044 final int? _val;
1045 final int? _count;
1046
1047 StatObjectBuilder({
1048 String? id,
1049 int? val,
1050 int? count,
1051 })
1052 : _id = id,
1053 _val = val,
1054 _count = count;
1055
1056 /// Finish building, and store into the [fbBuilder].
1057 @override
1058 int finish(fb.Builder fbBuilder) {
1059 final int? idOffset = _id == null ? null
1060 : fbBuilder.writeString(_id!);
1061 fbBuilder.startTable(3);
1062 fbBuilder.addOffset(0, idOffset);
1063 fbBuilder.addInt64(1, _val);
1064 fbBuilder.addUint16(2, _count);
1065 return fbBuilder.endTable();
1066 }
1067
1068 /// Convenience method to serialize to byte list.
1069 @override
1070 Uint8List toBytes([String? fileIdentifier]) {
1071 final fbBuilder = fb.Builder(deduplicateTables: false);
1072 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
1073 return fbBuilder.buffer;
1074 }
1075}
1076class Referrable {
1077 Referrable._(this._bc, this._bcOffset);
1078 factory Referrable(List<int> bytes) {
1079 final rootRef = fb.BufferContext.fromBytes(bytes);
1080 return reader.read(rootRef, 0);
1081 }
1082
1083 static const fb.Reader<Referrable> reader = _ReferrableReader();
1084
1085 final fb.BufferContext _bc;
1086 final int _bcOffset;
1087
1088 int get id => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 4, 0);
1089
1090 @override
1091 String toString() {
1092 return 'Referrable{id: ${id}}';
1093 }
1094
1095 ReferrableT unpack() => ReferrableT(
1096 id: id);
1097
1098 static int pack(fb.Builder fbBuilder, ReferrableT? object) {
1099 if (object == null) return 0;
1100 return object.pack(fbBuilder);
1101 }
1102}
1103
1104class ReferrableT implements fb.Packable {
1105 int id;
1106
1107 ReferrableT({
1108 this.id = 0});
1109
1110 @override
1111 int pack(fb.Builder fbBuilder) {
1112 fbBuilder.startTable(1);
1113 fbBuilder.addUint64(0, id);
1114 return fbBuilder.endTable();
1115 }
1116
1117 @override
1118 String toString() {
1119 return 'ReferrableT{id: ${id}}';
1120 }
1121}
1122
1123class _ReferrableReader extends fb.TableReader<Referrable> {
1124 const _ReferrableReader();
1125
1126 @override
1127 Referrable createObject(fb.BufferContext bc, int offset) =>
1128 Referrable._(bc, offset);
1129}
1130
1131class ReferrableBuilder {
1132 ReferrableBuilder(this.fbBuilder);
1133
1134 final fb.Builder fbBuilder;
1135
1136 void begin() {
1137 fbBuilder.startTable(1);
1138 }
1139
1140 int addId(int? id) {
1141 fbBuilder.addUint64(0, id);
1142 return fbBuilder.offset;
1143 }
1144
1145 int finish() {
1146 return fbBuilder.endTable();
1147 }
1148}
1149
1150class ReferrableObjectBuilder extends fb.ObjectBuilder {
1151 final int? _id;
1152
1153 ReferrableObjectBuilder({
1154 int? id,
1155 })
1156 : _id = id;
1157
1158 /// Finish building, and store into the [fbBuilder].
1159 @override
1160 int finish(fb.Builder fbBuilder) {
1161 fbBuilder.startTable(1);
1162 fbBuilder.addUint64(0, _id);
1163 return fbBuilder.endTable();
1164 }
1165
1166 /// Convenience method to serialize to byte list.
1167 @override
1168 Uint8List toBytes([String? fileIdentifier]) {
1169 final fbBuilder = fb.Builder(deduplicateTables: false);
1170 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
1171 return fbBuilder.buffer;
1172 }
1173}
1174/// an example documentation comment: "monster object"
1175class Monster {
1176 Monster._(this._bc, this._bcOffset);
1177 factory Monster(List<int> bytes) {
1178 final rootRef = fb.BufferContext.fromBytes(bytes);
1179 return reader.read(rootRef, 0);
1180 }
1181
1182 static const fb.Reader<Monster> reader = _MonsterReader();
1183
1184 final fb.BufferContext _bc;
1185 final int _bcOffset;
1186
1187 Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);
1188 int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);
1189 int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);
1190 String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
1191 List<int>? get inventory => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
1192 Color get color => Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));
1193 AnyTypeId? get testType => AnyTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18));
1194 dynamic get test {
1195 switch (testType?.value) {
1196 case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);
1197 case 2: return TestSimpleTableWithEnum.reader.vTableGetNullable(_bc, _bcOffset, 20);
1198 case 3: return my_game_example2.Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);
1199 default: return null;
1200 }
1201 }
1202 List<Test>? get test4 => const fb.ListReader<Test>(Test.reader).vTableGetNullable(_bc, _bcOffset, 22);
1203 List<String>? get testarrayofstring => const fb.ListReader<String>(fb.StringReader()).vTableGetNullable(_bc, _bcOffset, 24);
1204 /// an example documentation comment: this will end up in the generated code
1205 /// multiline too
1206 List<Monster>? get testarrayoftables => const fb.ListReader<Monster>(Monster.reader).vTableGetNullable(_bc, _bcOffset, 26);
1207 Monster? get enemy => Monster.reader.vTableGetNullable(_bc, _bcOffset, 28);
1208 List<int>? get testnestedflatbuffer => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 30);
1209 Stat? get testempty => Stat.reader.vTableGetNullable(_bc, _bcOffset, 32);
1210 bool get testbool => const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);
1211 int get testhashs32Fnv1 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 36, 0);
1212 int get testhashu32Fnv1 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 38, 0);
1213 int get testhashs64Fnv1 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 40, 0);
1214 int get testhashu64Fnv1 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 42, 0);
1215 int get testhashs32Fnv1a => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 44, 0);
1216 int get testhashu32Fnv1a => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 46, 0);
1217 int get testhashs64Fnv1a => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 48, 0);
1218 int get testhashu64Fnv1a => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);
1219 List<bool>? get testarrayofbools => const fb.ListReader<bool>(fb.BoolReader()).vTableGetNullable(_bc, _bcOffset, 52);
1220 double get testf => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);
1221 double get testf2 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 56, 3.0);
1222 double get testf3 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);
1223 List<String>? get testarrayofstring2 => const fb.ListReader<String>(fb.StringReader()).vTableGetNullable(_bc, _bcOffset, 60);
1224 List<Ability>? get testarrayofsortedstruct => const fb.ListReader<Ability>(Ability.reader).vTableGetNullable(_bc, _bcOffset, 62);
1225 List<int>? get flex => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 64);
1226 List<Test>? get test5 => const fb.ListReader<Test>(Test.reader).vTableGetNullable(_bc, _bcOffset, 66);
1227 List<int>? get vectorOfLongs => const fb.ListReader<int>(fb.Int64Reader()).vTableGetNullable(_bc, _bcOffset, 68);
1228 List<double>? get vectorOfDoubles => const fb.ListReader<double>(fb.Float64Reader()).vTableGetNullable(_bc, _bcOffset, 70);
1229 my_game.InParentNamespace? get parentNamespaceTest => my_game.InParentNamespace.reader.vTableGetNullable(_bc, _bcOffset, 72);
1230 List<Referrable>? get vectorOfReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGetNullable(_bc, _bcOffset, 74);
1231 int get singleWeakReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);
1232 List<int>? get vectorOfWeakReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 78);
1233 List<Referrable>? get vectorOfStrongReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGetNullable(_bc, _bcOffset, 80);
1234 int get coOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);
1235 List<int>? get vectorOfCoOwningReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 84);
1236 int get nonOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);
1237 List<int>? get vectorOfNonOwningReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 88);
1238 AnyUniqueAliasesTypeId? get anyUniqueType => AnyUniqueAliasesTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 90));
1239 dynamic get anyUnique {
1240 switch (anyUniqueType?.value) {
1241 case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);
1242 case 2: return TestSimpleTableWithEnum.reader.vTableGetNullable(_bc, _bcOffset, 92);
1243 case 3: return my_game_example2.Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);
1244 default: return null;
1245 }
1246 }
1247 AnyAmbiguousAliasesTypeId? get anyAmbiguousType => AnyAmbiguousAliasesTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 94));
1248 dynamic get anyAmbiguous {
1249 switch (anyAmbiguousType?.value) {
1250 case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
1251 case 2: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
1252 case 3: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
1253 default: return null;
1254 }
1255 }
1256 List<Color>? get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGetNullable(_bc, _bcOffset, 98);
1257 Race get signedEnum => Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
1258 List<int>? get testrequirednestedflatbuffer => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 102);
1259 List<Stat>? get scalarKeySortedTables => const fb.ListReader<Stat>(Stat.reader).vTableGetNullable(_bc, _bcOffset, 104);
1260 Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
1261 LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0));
1262 LongEnum get longEnumNormalDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2));
1263 double get nanDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
1264 double get infDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);
1265 double get positiveInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);
1266 double get infinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);
1267 double get positiveInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
1268 double get negativeInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 122, double.negativeInfinity);
1269 double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 124, double.negativeInfinity);
1270 double get doubleInfDefault => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
1271
1272 @override
1273 String toString() {
1274 return 'Monster{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
1275 }
1276
1277 MonsterT unpack() => MonsterT(
1278 pos: pos?.unpack(),
1279 mana: mana,
1280 hp: hp,
1281 name: name,
1282 inventory: const fb.Uint8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 14),
1283 color: color,
1284 testType: testType,
1285 test: test,
1286 test4: test4?.map((e) => e.unpack()).toList(),
1287 testarrayofstring: const fb.ListReader<String>(fb.StringReader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 24),
1288 testarrayoftables: testarrayoftables?.map((e) => e.unpack()).toList(),
1289 enemy: enemy?.unpack(),
1290 testnestedflatbuffer: const fb.Uint8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 30),
1291 testempty: testempty?.unpack(),
1292 testbool: testbool,
1293 testhashs32Fnv1: testhashs32Fnv1,
1294 testhashu32Fnv1: testhashu32Fnv1,
1295 testhashs64Fnv1: testhashs64Fnv1,
1296 testhashu64Fnv1: testhashu64Fnv1,
1297 testhashs32Fnv1a: testhashs32Fnv1a,
1298 testhashu32Fnv1a: testhashu32Fnv1a,
1299 testhashs64Fnv1a: testhashs64Fnv1a,
1300 testhashu64Fnv1a: testhashu64Fnv1a,
1301 testarrayofbools: const fb.ListReader<bool>(fb.BoolReader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 52),
1302 testf: testf,
1303 testf2: testf2,
1304 testf3: testf3,
1305 testarrayofstring2: const fb.ListReader<String>(fb.StringReader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 60),
1306 testarrayofsortedstruct: testarrayofsortedstruct?.map((e) => e.unpack()).toList(),
1307 flex: const fb.Uint8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 64),
1308 test5: test5?.map((e) => e.unpack()).toList(),
1309 vectorOfLongs: const fb.ListReader<int>(fb.Int64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 68),
1310 vectorOfDoubles: const fb.ListReader<double>(fb.Float64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 70),
1311 parentNamespaceTest: parentNamespaceTest?.unpack(),
1312 vectorOfReferrables: vectorOfReferrables?.map((e) => e.unpack()).toList(),
1313 singleWeakReference: singleWeakReference,
1314 vectorOfWeakReferences: const fb.ListReader<int>(fb.Uint64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 78),
1315 vectorOfStrongReferrables: vectorOfStrongReferrables?.map((e) => e.unpack()).toList(),
1316 coOwningReference: coOwningReference,
1317 vectorOfCoOwningReferences: const fb.ListReader<int>(fb.Uint64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 84),
1318 nonOwningReference: nonOwningReference,
1319 vectorOfNonOwningReferences: const fb.ListReader<int>(fb.Uint64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 88),
1320 anyUniqueType: anyUniqueType,
1321 anyUnique: anyUnique,
1322 anyAmbiguousType: anyAmbiguousType,
1323 anyAmbiguous: anyAmbiguous,
1324 vectorOfEnums: const fb.ListReader<Color>(Color.reader, lazy: false).vTableGetNullable(_bc, _bcOffset, 98),
1325 signedEnum: signedEnum,
1326 testrequirednestedflatbuffer: const fb.Uint8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 102),
1327 scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList(),
1328 nativeInline: nativeInline?.unpack(),
1329 longEnumNonEnumDefault: longEnumNonEnumDefault,
1330 longEnumNormalDefault: longEnumNormalDefault,
1331 nanDefault: nanDefault,
1332 infDefault: infDefault,
1333 positiveInfDefault: positiveInfDefault,
1334 infinityDefault: infinityDefault,
1335 positiveInfinityDefault: positiveInfinityDefault,
1336 negativeInfDefault: negativeInfDefault,
1337 negativeInfinityDefault: negativeInfinityDefault,
1338 doubleInfDefault: doubleInfDefault);
1339
1340 static int pack(fb.Builder fbBuilder, MonsterT? object) {
1341 if (object == null) return 0;
1342 return object.pack(fbBuilder);
1343 }
1344}
1345
1346/// an example documentation comment: "monster object"
1347class MonsterT implements fb.Packable {
1348 Vec3T? pos;
1349 int mana;
1350 int hp;
1351 String? name;
1352 List<int>? inventory;
1353 Color color;
1354 AnyTypeId? testType;
1355 dynamic test;
1356 List<TestT>? test4;
1357 List<String>? testarrayofstring;
1358 /// an example documentation comment: this will end up in the generated code
1359 /// multiline too
1360 List<MonsterT>? testarrayoftables;
1361 MonsterT? enemy;
1362 List<int>? testnestedflatbuffer;
1363 StatT? testempty;
1364 bool testbool;
1365 int testhashs32Fnv1;
1366 int testhashu32Fnv1;
1367 int testhashs64Fnv1;
1368 int testhashu64Fnv1;
1369 int testhashs32Fnv1a;
1370 int testhashu32Fnv1a;
1371 int testhashs64Fnv1a;
1372 int testhashu64Fnv1a;
1373 List<bool>? testarrayofbools;
1374 double testf;
1375 double testf2;
1376 double testf3;
1377 List<String>? testarrayofstring2;
1378 List<AbilityT>? testarrayofsortedstruct;
1379 List<int>? flex;
1380 List<TestT>? test5;
1381 List<int>? vectorOfLongs;
1382 List<double>? vectorOfDoubles;
1383 my_game.InParentNamespaceT? parentNamespaceTest;
1384 List<ReferrableT>? vectorOfReferrables;
1385 int singleWeakReference;
1386 List<int>? vectorOfWeakReferences;
1387 List<ReferrableT>? vectorOfStrongReferrables;
1388 int coOwningReference;
1389 List<int>? vectorOfCoOwningReferences;
1390 int nonOwningReference;
1391 List<int>? vectorOfNonOwningReferences;
1392 AnyUniqueAliasesTypeId? anyUniqueType;
1393 dynamic anyUnique;
1394 AnyAmbiguousAliasesTypeId? anyAmbiguousType;
1395 dynamic anyAmbiguous;
1396 List<Color>? vectorOfEnums;
1397 Race signedEnum;
1398 List<int>? testrequirednestedflatbuffer;
1399 List<StatT>? scalarKeySortedTables;
1400 TestT? nativeInline;
1401 LongEnum longEnumNonEnumDefault;
1402 LongEnum longEnumNormalDefault;
1403 double nanDefault;
1404 double infDefault;
1405 double positiveInfDefault;
1406 double infinityDefault;
1407 double positiveInfinityDefault;
1408 double negativeInfDefault;
1409 double negativeInfinityDefault;
1410 double doubleInfDefault;
1411
1412 MonsterT({
1413 this.pos,
1414 this.mana = 150,
1415 this.hp = 100,
1416 this.name,
1417 this.inventory,
1418 this.color = Color.Blue,
1419 this.testType,
1420 this.test,
1421 this.test4,
1422 this.testarrayofstring,
1423 this.testarrayoftables,
1424 this.enemy,
1425 this.testnestedflatbuffer,
1426 this.testempty,
1427 this.testbool = false,
1428 this.testhashs32Fnv1 = 0,
1429 this.testhashu32Fnv1 = 0,
1430 this.testhashs64Fnv1 = 0,
1431 this.testhashu64Fnv1 = 0,
1432 this.testhashs32Fnv1a = 0,
1433 this.testhashu32Fnv1a = 0,
1434 this.testhashs64Fnv1a = 0,
1435 this.testhashu64Fnv1a = 0,
1436 this.testarrayofbools,
1437 this.testf = 3.14159,
1438 this.testf2 = 3.0,
1439 this.testf3 = 0.0,
1440 this.testarrayofstring2,
1441 this.testarrayofsortedstruct,
1442 this.flex,
1443 this.test5,
1444 this.vectorOfLongs,
1445 this.vectorOfDoubles,
1446 this.parentNamespaceTest,
1447 this.vectorOfReferrables,
1448 this.singleWeakReference = 0,
1449 this.vectorOfWeakReferences,
1450 this.vectorOfStrongReferrables,
1451 this.coOwningReference = 0,
1452 this.vectorOfCoOwningReferences,
1453 this.nonOwningReference = 0,
1454 this.vectorOfNonOwningReferences,
1455 this.anyUniqueType,
1456 this.anyUnique,
1457 this.anyAmbiguousType,
1458 this.anyAmbiguous,
1459 this.vectorOfEnums,
1460 this.signedEnum = Race.None,
1461 this.testrequirednestedflatbuffer,
1462 this.scalarKeySortedTables,
1463 this.nativeInline,
1464 this.longEnumNonEnumDefault = const LongEnum._(0),
1465 this.longEnumNormalDefault = LongEnum.LongOne,
1466 this.nanDefault = double.nan,
1467 this.infDefault = double.infinity,
1468 this.positiveInfDefault = double.infinity,
1469 this.infinityDefault = double.infinity,
1470 this.positiveInfinityDefault = double.infinity,
1471 this.negativeInfDefault = double.negativeInfinity,
1472 this.negativeInfinityDefault = double.negativeInfinity,
1473 this.doubleInfDefault = double.infinity});
1474
1475 @override
1476 int pack(fb.Builder fbBuilder) {
1477 final int? nameOffset = name == null ? null
1478 : fbBuilder.writeString(name!);
1479 final int? inventoryOffset = inventory == null ? null
1480 : fbBuilder.writeListUint8(inventory!);
1481 final int? testOffset = test?.pack(fbBuilder);
1482 int? test4Offset;
1483 if (test4 != null) {
1484 for (var e in test4!) { e.pack(fbBuilder); }
1485 test4Offset = fbBuilder.endStructVector(test4!.length);
1486 }
1487 final int? testarrayofstringOffset = testarrayofstring == null ? null
1488 : fbBuilder.writeList(testarrayofstring!.map(fbBuilder.writeString).toList());
1489 final int? testarrayoftablesOffset = testarrayoftables == null ? null
1490 : fbBuilder.writeList(testarrayoftables!.map((b) => b.pack(fbBuilder)).toList());
1491 final int? enemyOffset = enemy?.pack(fbBuilder);
1492 final int? testnestedflatbufferOffset = testnestedflatbuffer == null ? null
1493 : fbBuilder.writeListUint8(testnestedflatbuffer!);
1494 final int? testemptyOffset = testempty?.pack(fbBuilder);
1495 final int? testarrayofboolsOffset = testarrayofbools == null ? null
1496 : fbBuilder.writeListBool(testarrayofbools!);
1497 final int? testarrayofstring2Offset = testarrayofstring2 == null ? null
1498 : fbBuilder.writeList(testarrayofstring2!.map(fbBuilder.writeString).toList());
1499 int? testarrayofsortedstructOffset;
1500 if (testarrayofsortedstruct != null) {
1501 for (var e in testarrayofsortedstruct!) { e.pack(fbBuilder); }
1502 testarrayofsortedstructOffset = fbBuilder.endStructVector(testarrayofsortedstruct!.length);
1503 }
1504 final int? flexOffset = flex == null ? null
1505 : fbBuilder.writeListUint8(flex!);
1506 int? test5Offset;
1507 if (test5 != null) {
1508 for (var e in test5!) { e.pack(fbBuilder); }
1509 test5Offset = fbBuilder.endStructVector(test5!.length);
1510 }
1511 final int? vectorOfLongsOffset = vectorOfLongs == null ? null
1512 : fbBuilder.writeListInt64(vectorOfLongs!);
1513 final int? vectorOfDoublesOffset = vectorOfDoubles == null ? null
1514 : fbBuilder.writeListFloat64(vectorOfDoubles!);
1515 final int? parentNamespaceTestOffset = parentNamespaceTest?.pack(fbBuilder);
1516 final int? vectorOfReferrablesOffset = vectorOfReferrables == null ? null
1517 : fbBuilder.writeList(vectorOfReferrables!.map((b) => b.pack(fbBuilder)).toList());
1518 final int? vectorOfWeakReferencesOffset = vectorOfWeakReferences == null ? null
1519 : fbBuilder.writeListUint64(vectorOfWeakReferences!);
1520 final int? vectorOfStrongReferrablesOffset = vectorOfStrongReferrables == null ? null
1521 : fbBuilder.writeList(vectorOfStrongReferrables!.map((b) => b.pack(fbBuilder)).toList());
1522 final int? vectorOfCoOwningReferencesOffset = vectorOfCoOwningReferences == null ? null
1523 : fbBuilder.writeListUint64(vectorOfCoOwningReferences!);
1524 final int? vectorOfNonOwningReferencesOffset = vectorOfNonOwningReferences == null ? null
1525 : fbBuilder.writeListUint64(vectorOfNonOwningReferences!);
1526 final int? anyUniqueOffset = anyUnique?.pack(fbBuilder);
1527 final int? anyAmbiguousOffset = anyAmbiguous?.pack(fbBuilder);
1528 final int? vectorOfEnumsOffset = vectorOfEnums == null ? null
1529 : fbBuilder.writeListUint8(vectorOfEnums!.map((f) => f.value).toList());
1530 final int? testrequirednestedflatbufferOffset = testrequirednestedflatbuffer == null ? null
1531 : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
1532 final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null ? null
1533 : fbBuilder.writeList(scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList());
1534 fbBuilder.startTable(62);
1535 if (pos != null) {
1536 fbBuilder.addStruct(0, pos!.pack(fbBuilder));
1537 }
1538 fbBuilder.addInt16(1, mana);
1539 fbBuilder.addInt16(2, hp);
1540 fbBuilder.addOffset(3, nameOffset);
1541 fbBuilder.addOffset(5, inventoryOffset);
1542 fbBuilder.addUint8(6, color.value);
1543 fbBuilder.addUint8(7, testType?.value);
1544 fbBuilder.addOffset(8, testOffset);
1545 fbBuilder.addOffset(9, test4Offset);
1546 fbBuilder.addOffset(10, testarrayofstringOffset);
1547 fbBuilder.addOffset(11, testarrayoftablesOffset);
1548 fbBuilder.addOffset(12, enemyOffset);
1549 fbBuilder.addOffset(13, testnestedflatbufferOffset);
1550 fbBuilder.addOffset(14, testemptyOffset);
1551 fbBuilder.addBool(15, testbool);
1552 fbBuilder.addInt32(16, testhashs32Fnv1);
1553 fbBuilder.addUint32(17, testhashu32Fnv1);
1554 fbBuilder.addInt64(18, testhashs64Fnv1);
1555 fbBuilder.addUint64(19, testhashu64Fnv1);
1556 fbBuilder.addInt32(20, testhashs32Fnv1a);
1557 fbBuilder.addUint32(21, testhashu32Fnv1a);
1558 fbBuilder.addInt64(22, testhashs64Fnv1a);
1559 fbBuilder.addUint64(23, testhashu64Fnv1a);
1560 fbBuilder.addOffset(24, testarrayofboolsOffset);
1561 fbBuilder.addFloat32(25, testf);
1562 fbBuilder.addFloat32(26, testf2);
1563 fbBuilder.addFloat32(27, testf3);
1564 fbBuilder.addOffset(28, testarrayofstring2Offset);
1565 fbBuilder.addOffset(29, testarrayofsortedstructOffset);
1566 fbBuilder.addOffset(30, flexOffset);
1567 fbBuilder.addOffset(31, test5Offset);
1568 fbBuilder.addOffset(32, vectorOfLongsOffset);
1569 fbBuilder.addOffset(33, vectorOfDoublesOffset);
1570 fbBuilder.addOffset(34, parentNamespaceTestOffset);
1571 fbBuilder.addOffset(35, vectorOfReferrablesOffset);
1572 fbBuilder.addUint64(36, singleWeakReference);
1573 fbBuilder.addOffset(37, vectorOfWeakReferencesOffset);
1574 fbBuilder.addOffset(38, vectorOfStrongReferrablesOffset);
1575 fbBuilder.addUint64(39, coOwningReference);
1576 fbBuilder.addOffset(40, vectorOfCoOwningReferencesOffset);
1577 fbBuilder.addUint64(41, nonOwningReference);
1578 fbBuilder.addOffset(42, vectorOfNonOwningReferencesOffset);
1579 fbBuilder.addUint8(43, anyUniqueType?.value);
1580 fbBuilder.addOffset(44, anyUniqueOffset);
1581 fbBuilder.addUint8(45, anyAmbiguousType?.value);
1582 fbBuilder.addOffset(46, anyAmbiguousOffset);
1583 fbBuilder.addOffset(47, vectorOfEnumsOffset);
1584 fbBuilder.addInt8(48, signedEnum.value);
1585 fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
1586 fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
1587 if (nativeInline != null) {
1588 fbBuilder.addStruct(51, nativeInline!.pack(fbBuilder));
1589 }
1590 fbBuilder.addUint64(52, longEnumNonEnumDefault.value);
1591 fbBuilder.addUint64(53, longEnumNormalDefault.value);
1592 fbBuilder.addFloat32(54, nanDefault);
1593 fbBuilder.addFloat32(55, infDefault);
1594 fbBuilder.addFloat32(56, positiveInfDefault);
1595 fbBuilder.addFloat32(57, infinityDefault);
1596 fbBuilder.addFloat32(58, positiveInfinityDefault);
1597 fbBuilder.addFloat32(59, negativeInfDefault);
1598 fbBuilder.addFloat32(60, negativeInfinityDefault);
1599 fbBuilder.addFloat64(61, doubleInfDefault);
1600 return fbBuilder.endTable();
1601 }
1602
1603 @override
1604 String toString() {
1605 return 'MonsterT{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
1606 }
1607}
1608
1609class _MonsterReader extends fb.TableReader<Monster> {
1610 const _MonsterReader();
1611
1612 @override
1613 Monster createObject(fb.BufferContext bc, int offset) =>
1614 Monster._(bc, offset);
1615}
1616
1617class MonsterBuilder {
1618 MonsterBuilder(this.fbBuilder);
1619
1620 final fb.Builder fbBuilder;
1621
1622 void begin() {
1623 fbBuilder.startTable(62);
1624 }
1625
1626 int addPos(int offset) {
1627 fbBuilder.addStruct(0, offset);
1628 return fbBuilder.offset;
1629 }
1630 int addMana(int? mana) {
1631 fbBuilder.addInt16(1, mana);
1632 return fbBuilder.offset;
1633 }
1634 int addHp(int? hp) {
1635 fbBuilder.addInt16(2, hp);
1636 return fbBuilder.offset;
1637 }
1638 int addNameOffset(int? offset) {
1639 fbBuilder.addOffset(3, offset);
1640 return fbBuilder.offset;
1641 }
1642 int addInventoryOffset(int? offset) {
1643 fbBuilder.addOffset(5, offset);
1644 return fbBuilder.offset;
1645 }
1646 int addColor(Color? color) {
1647 fbBuilder.addUint8(6, color?.value);
1648 return fbBuilder.offset;
1649 }
1650 int addTestType(AnyTypeId? testType) {
1651 fbBuilder.addUint8(7, testType?.value);
1652 return fbBuilder.offset;
1653 }
1654 int addTestOffset(int? offset) {
1655 fbBuilder.addOffset(8, offset);
1656 return fbBuilder.offset;
1657 }
1658 int addTest4Offset(int? offset) {
1659 fbBuilder.addOffset(9, offset);
1660 return fbBuilder.offset;
1661 }
1662 int addTestarrayofstringOffset(int? offset) {
1663 fbBuilder.addOffset(10, offset);
1664 return fbBuilder.offset;
1665 }
1666 int addTestarrayoftablesOffset(int? offset) {
1667 fbBuilder.addOffset(11, offset);
1668 return fbBuilder.offset;
1669 }
1670 int addEnemyOffset(int? offset) {
1671 fbBuilder.addOffset(12, offset);
1672 return fbBuilder.offset;
1673 }
1674 int addTestnestedflatbufferOffset(int? offset) {
1675 fbBuilder.addOffset(13, offset);
1676 return fbBuilder.offset;
1677 }
1678 int addTestemptyOffset(int? offset) {
1679 fbBuilder.addOffset(14, offset);
1680 return fbBuilder.offset;
1681 }
1682 int addTestbool(bool? testbool) {
1683 fbBuilder.addBool(15, testbool);
1684 return fbBuilder.offset;
1685 }
1686 int addTesthashs32Fnv1(int? testhashs32Fnv1) {
1687 fbBuilder.addInt32(16, testhashs32Fnv1);
1688 return fbBuilder.offset;
1689 }
1690 int addTesthashu32Fnv1(int? testhashu32Fnv1) {
1691 fbBuilder.addUint32(17, testhashu32Fnv1);
1692 return fbBuilder.offset;
1693 }
1694 int addTesthashs64Fnv1(int? testhashs64Fnv1) {
1695 fbBuilder.addInt64(18, testhashs64Fnv1);
1696 return fbBuilder.offset;
1697 }
1698 int addTesthashu64Fnv1(int? testhashu64Fnv1) {
1699 fbBuilder.addUint64(19, testhashu64Fnv1);
1700 return fbBuilder.offset;
1701 }
1702 int addTesthashs32Fnv1a(int? testhashs32Fnv1a) {
1703 fbBuilder.addInt32(20, testhashs32Fnv1a);
1704 return fbBuilder.offset;
1705 }
1706 int addTesthashu32Fnv1a(int? testhashu32Fnv1a) {
1707 fbBuilder.addUint32(21, testhashu32Fnv1a);
1708 return fbBuilder.offset;
1709 }
1710 int addTesthashs64Fnv1a(int? testhashs64Fnv1a) {
1711 fbBuilder.addInt64(22, testhashs64Fnv1a);
1712 return fbBuilder.offset;
1713 }
1714 int addTesthashu64Fnv1a(int? testhashu64Fnv1a) {
1715 fbBuilder.addUint64(23, testhashu64Fnv1a);
1716 return fbBuilder.offset;
1717 }
1718 int addTestarrayofboolsOffset(int? offset) {
1719 fbBuilder.addOffset(24, offset);
1720 return fbBuilder.offset;
1721 }
1722 int addTestf(double? testf) {
1723 fbBuilder.addFloat32(25, testf);
1724 return fbBuilder.offset;
1725 }
1726 int addTestf2(double? testf2) {
1727 fbBuilder.addFloat32(26, testf2);
1728 return fbBuilder.offset;
1729 }
1730 int addTestf3(double? testf3) {
1731 fbBuilder.addFloat32(27, testf3);
1732 return fbBuilder.offset;
1733 }
1734 int addTestarrayofstring2Offset(int? offset) {
1735 fbBuilder.addOffset(28, offset);
1736 return fbBuilder.offset;
1737 }
1738 int addTestarrayofsortedstructOffset(int? offset) {
1739 fbBuilder.addOffset(29, offset);
1740 return fbBuilder.offset;
1741 }
1742 int addFlexOffset(int? offset) {
1743 fbBuilder.addOffset(30, offset);
1744 return fbBuilder.offset;
1745 }
1746 int addTest5Offset(int? offset) {
1747 fbBuilder.addOffset(31, offset);
1748 return fbBuilder.offset;
1749 }
1750 int addVectorOfLongsOffset(int? offset) {
1751 fbBuilder.addOffset(32, offset);
1752 return fbBuilder.offset;
1753 }
1754 int addVectorOfDoublesOffset(int? offset) {
1755 fbBuilder.addOffset(33, offset);
1756 return fbBuilder.offset;
1757 }
1758 int addParentNamespaceTestOffset(int? offset) {
1759 fbBuilder.addOffset(34, offset);
1760 return fbBuilder.offset;
1761 }
1762 int addVectorOfReferrablesOffset(int? offset) {
1763 fbBuilder.addOffset(35, offset);
1764 return fbBuilder.offset;
1765 }
1766 int addSingleWeakReference(int? singleWeakReference) {
1767 fbBuilder.addUint64(36, singleWeakReference);
1768 return fbBuilder.offset;
1769 }
1770 int addVectorOfWeakReferencesOffset(int? offset) {
1771 fbBuilder.addOffset(37, offset);
1772 return fbBuilder.offset;
1773 }
1774 int addVectorOfStrongReferrablesOffset(int? offset) {
1775 fbBuilder.addOffset(38, offset);
1776 return fbBuilder.offset;
1777 }
1778 int addCoOwningReference(int? coOwningReference) {
1779 fbBuilder.addUint64(39, coOwningReference);
1780 return fbBuilder.offset;
1781 }
1782 int addVectorOfCoOwningReferencesOffset(int? offset) {
1783 fbBuilder.addOffset(40, offset);
1784 return fbBuilder.offset;
1785 }
1786 int addNonOwningReference(int? nonOwningReference) {
1787 fbBuilder.addUint64(41, nonOwningReference);
1788 return fbBuilder.offset;
1789 }
1790 int addVectorOfNonOwningReferencesOffset(int? offset) {
1791 fbBuilder.addOffset(42, offset);
1792 return fbBuilder.offset;
1793 }
1794 int addAnyUniqueType(AnyUniqueAliasesTypeId? anyUniqueType) {
1795 fbBuilder.addUint8(43, anyUniqueType?.value);
1796 return fbBuilder.offset;
1797 }
1798 int addAnyUniqueOffset(int? offset) {
1799 fbBuilder.addOffset(44, offset);
1800 return fbBuilder.offset;
1801 }
1802 int addAnyAmbiguousType(AnyAmbiguousAliasesTypeId? anyAmbiguousType) {
1803 fbBuilder.addUint8(45, anyAmbiguousType?.value);
1804 return fbBuilder.offset;
1805 }
1806 int addAnyAmbiguousOffset(int? offset) {
1807 fbBuilder.addOffset(46, offset);
1808 return fbBuilder.offset;
1809 }
1810 int addVectorOfEnumsOffset(int? offset) {
1811 fbBuilder.addOffset(47, offset);
1812 return fbBuilder.offset;
1813 }
1814 int addSignedEnum(Race? signedEnum) {
1815 fbBuilder.addInt8(48, signedEnum?.value);
1816 return fbBuilder.offset;
1817 }
1818 int addTestrequirednestedflatbufferOffset(int? offset) {
1819 fbBuilder.addOffset(49, offset);
1820 return fbBuilder.offset;
1821 }
1822 int addScalarKeySortedTablesOffset(int? offset) {
1823 fbBuilder.addOffset(50, offset);
1824 return fbBuilder.offset;
1825 }
1826 int addNativeInline(int offset) {
1827 fbBuilder.addStruct(51, offset);
1828 return fbBuilder.offset;
1829 }
1830 int addLongEnumNonEnumDefault(LongEnum? longEnumNonEnumDefault) {
1831 fbBuilder.addUint64(52, longEnumNonEnumDefault?.value);
1832 return fbBuilder.offset;
1833 }
1834 int addLongEnumNormalDefault(LongEnum? longEnumNormalDefault) {
1835 fbBuilder.addUint64(53, longEnumNormalDefault?.value);
1836 return fbBuilder.offset;
1837 }
1838 int addNanDefault(double? nanDefault) {
1839 fbBuilder.addFloat32(54, nanDefault);
1840 return fbBuilder.offset;
1841 }
1842 int addInfDefault(double? infDefault) {
1843 fbBuilder.addFloat32(55, infDefault);
1844 return fbBuilder.offset;
1845 }
1846 int addPositiveInfDefault(double? positiveInfDefault) {
1847 fbBuilder.addFloat32(56, positiveInfDefault);
1848 return fbBuilder.offset;
1849 }
1850 int addInfinityDefault(double? infinityDefault) {
1851 fbBuilder.addFloat32(57, infinityDefault);
1852 return fbBuilder.offset;
1853 }
1854 int addPositiveInfinityDefault(double? positiveInfinityDefault) {
1855 fbBuilder.addFloat32(58, positiveInfinityDefault);
1856 return fbBuilder.offset;
1857 }
1858 int addNegativeInfDefault(double? negativeInfDefault) {
1859 fbBuilder.addFloat32(59, negativeInfDefault);
1860 return fbBuilder.offset;
1861 }
1862 int addNegativeInfinityDefault(double? negativeInfinityDefault) {
1863 fbBuilder.addFloat32(60, negativeInfinityDefault);
1864 return fbBuilder.offset;
1865 }
1866 int addDoubleInfDefault(double? doubleInfDefault) {
1867 fbBuilder.addFloat64(61, doubleInfDefault);
1868 return fbBuilder.offset;
1869 }
1870
1871 int finish() {
1872 return fbBuilder.endTable();
1873 }
1874}
1875
1876class MonsterObjectBuilder extends fb.ObjectBuilder {
1877 final Vec3ObjectBuilder? _pos;
1878 final int? _mana;
1879 final int? _hp;
1880 final String? _name;
1881 final List<int>? _inventory;
1882 final Color? _color;
1883 final AnyTypeId? _testType;
1884 final dynamic _test;
1885 final List<TestObjectBuilder>? _test4;
1886 final List<String>? _testarrayofstring;
1887 final List<MonsterObjectBuilder>? _testarrayoftables;
1888 final MonsterObjectBuilder? _enemy;
1889 final List<int>? _testnestedflatbuffer;
1890 final StatObjectBuilder? _testempty;
1891 final bool? _testbool;
1892 final int? _testhashs32Fnv1;
1893 final int? _testhashu32Fnv1;
1894 final int? _testhashs64Fnv1;
1895 final int? _testhashu64Fnv1;
1896 final int? _testhashs32Fnv1a;
1897 final int? _testhashu32Fnv1a;
1898 final int? _testhashs64Fnv1a;
1899 final int? _testhashu64Fnv1a;
1900 final List<bool>? _testarrayofbools;
1901 final double? _testf;
1902 final double? _testf2;
1903 final double? _testf3;
1904 final List<String>? _testarrayofstring2;
1905 final List<AbilityObjectBuilder>? _testarrayofsortedstruct;
1906 final List<int>? _flex;
1907 final List<TestObjectBuilder>? _test5;
1908 final List<int>? _vectorOfLongs;
1909 final List<double>? _vectorOfDoubles;
1910 final my_game.InParentNamespaceObjectBuilder? _parentNamespaceTest;
1911 final List<ReferrableObjectBuilder>? _vectorOfReferrables;
1912 final int? _singleWeakReference;
1913 final List<int>? _vectorOfWeakReferences;
1914 final List<ReferrableObjectBuilder>? _vectorOfStrongReferrables;
1915 final int? _coOwningReference;
1916 final List<int>? _vectorOfCoOwningReferences;
1917 final int? _nonOwningReference;
1918 final List<int>? _vectorOfNonOwningReferences;
1919 final AnyUniqueAliasesTypeId? _anyUniqueType;
1920 final dynamic _anyUnique;
1921 final AnyAmbiguousAliasesTypeId? _anyAmbiguousType;
1922 final dynamic _anyAmbiguous;
1923 final List<Color>? _vectorOfEnums;
1924 final Race? _signedEnum;
1925 final List<int>? _testrequirednestedflatbuffer;
1926 final List<StatObjectBuilder>? _scalarKeySortedTables;
1927 final TestObjectBuilder? _nativeInline;
1928 final LongEnum? _longEnumNonEnumDefault;
1929 final LongEnum? _longEnumNormalDefault;
1930 final double? _nanDefault;
1931 final double? _infDefault;
1932 final double? _positiveInfDefault;
1933 final double? _infinityDefault;
1934 final double? _positiveInfinityDefault;
1935 final double? _negativeInfDefault;
1936 final double? _negativeInfinityDefault;
1937 final double? _doubleInfDefault;
1938
1939 MonsterObjectBuilder({
1940 Vec3ObjectBuilder? pos,
1941 int? mana,
1942 int? hp,
1943 String? name,
1944 List<int>? inventory,
1945 Color? color,
1946 AnyTypeId? testType,
1947 dynamic test,
1948 List<TestObjectBuilder>? test4,
1949 List<String>? testarrayofstring,
1950 List<MonsterObjectBuilder>? testarrayoftables,
1951 MonsterObjectBuilder? enemy,
1952 List<int>? testnestedflatbuffer,
1953 StatObjectBuilder? testempty,
1954 bool? testbool,
1955 int? testhashs32Fnv1,
1956 int? testhashu32Fnv1,
1957 int? testhashs64Fnv1,
1958 int? testhashu64Fnv1,
1959 int? testhashs32Fnv1a,
1960 int? testhashu32Fnv1a,
1961 int? testhashs64Fnv1a,
1962 int? testhashu64Fnv1a,
1963 List<bool>? testarrayofbools,
1964 double? testf,
1965 double? testf2,
1966 double? testf3,
1967 List<String>? testarrayofstring2,
1968 List<AbilityObjectBuilder>? testarrayofsortedstruct,
1969 List<int>? flex,
1970 List<TestObjectBuilder>? test5,
1971 List<int>? vectorOfLongs,
1972 List<double>? vectorOfDoubles,
1973 my_game.InParentNamespaceObjectBuilder? parentNamespaceTest,
1974 List<ReferrableObjectBuilder>? vectorOfReferrables,
1975 int? singleWeakReference,
1976 List<int>? vectorOfWeakReferences,
1977 List<ReferrableObjectBuilder>? vectorOfStrongReferrables,
1978 int? coOwningReference,
1979 List<int>? vectorOfCoOwningReferences,
1980 int? nonOwningReference,
1981 List<int>? vectorOfNonOwningReferences,
1982 AnyUniqueAliasesTypeId? anyUniqueType,
1983 dynamic anyUnique,
1984 AnyAmbiguousAliasesTypeId? anyAmbiguousType,
1985 dynamic anyAmbiguous,
1986 List<Color>? vectorOfEnums,
1987 Race? signedEnum,
1988 List<int>? testrequirednestedflatbuffer,
1989 List<StatObjectBuilder>? scalarKeySortedTables,
1990 TestObjectBuilder? nativeInline,
1991 LongEnum? longEnumNonEnumDefault,
1992 LongEnum? longEnumNormalDefault,
1993 double? nanDefault,
1994 double? infDefault,
1995 double? positiveInfDefault,
1996 double? infinityDefault,
1997 double? positiveInfinityDefault,
1998 double? negativeInfDefault,
1999 double? negativeInfinityDefault,
2000 double? doubleInfDefault,
2001 })
2002 : _pos = pos,
2003 _mana = mana,
2004 _hp = hp,
2005 _name = name,
2006 _inventory = inventory,
2007 _color = color,
2008 _testType = testType,
2009 _test = test,
2010 _test4 = test4,
2011 _testarrayofstring = testarrayofstring,
2012 _testarrayoftables = testarrayoftables,
2013 _enemy = enemy,
2014 _testnestedflatbuffer = testnestedflatbuffer,
2015 _testempty = testempty,
2016 _testbool = testbool,
2017 _testhashs32Fnv1 = testhashs32Fnv1,
2018 _testhashu32Fnv1 = testhashu32Fnv1,
2019 _testhashs64Fnv1 = testhashs64Fnv1,
2020 _testhashu64Fnv1 = testhashu64Fnv1,
2021 _testhashs32Fnv1a = testhashs32Fnv1a,
2022 _testhashu32Fnv1a = testhashu32Fnv1a,
2023 _testhashs64Fnv1a = testhashs64Fnv1a,
2024 _testhashu64Fnv1a = testhashu64Fnv1a,
2025 _testarrayofbools = testarrayofbools,
2026 _testf = testf,
2027 _testf2 = testf2,
2028 _testf3 = testf3,
2029 _testarrayofstring2 = testarrayofstring2,
2030 _testarrayofsortedstruct = testarrayofsortedstruct,
2031 _flex = flex,
2032 _test5 = test5,
2033 _vectorOfLongs = vectorOfLongs,
2034 _vectorOfDoubles = vectorOfDoubles,
2035 _parentNamespaceTest = parentNamespaceTest,
2036 _vectorOfReferrables = vectorOfReferrables,
2037 _singleWeakReference = singleWeakReference,
2038 _vectorOfWeakReferences = vectorOfWeakReferences,
2039 _vectorOfStrongReferrables = vectorOfStrongReferrables,
2040 _coOwningReference = coOwningReference,
2041 _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
2042 _nonOwningReference = nonOwningReference,
2043 _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
2044 _anyUniqueType = anyUniqueType,
2045 _anyUnique = anyUnique,
2046 _anyAmbiguousType = anyAmbiguousType,
2047 _anyAmbiguous = anyAmbiguous,
2048 _vectorOfEnums = vectorOfEnums,
2049 _signedEnum = signedEnum,
2050 _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
2051 _scalarKeySortedTables = scalarKeySortedTables,
2052 _nativeInline = nativeInline,
2053 _longEnumNonEnumDefault = longEnumNonEnumDefault,
2054 _longEnumNormalDefault = longEnumNormalDefault,
2055 _nanDefault = nanDefault,
2056 _infDefault = infDefault,
2057 _positiveInfDefault = positiveInfDefault,
2058 _infinityDefault = infinityDefault,
2059 _positiveInfinityDefault = positiveInfinityDefault,
2060 _negativeInfDefault = negativeInfDefault,
2061 _negativeInfinityDefault = negativeInfinityDefault,
2062 _doubleInfDefault = doubleInfDefault;
2063
2064 /// Finish building, and store into the [fbBuilder].
2065 @override
2066 int finish(fb.Builder fbBuilder) {
2067 final int? nameOffset = _name == null ? null
2068 : fbBuilder.writeString(_name!);
2069 final int? inventoryOffset = _inventory == null ? null
2070 : fbBuilder.writeListUint8(_inventory!);
2071 final int? testOffset = _test?.getOrCreateOffset(fbBuilder);
2072 final int? test4Offset = _test4 == null ? null
2073 : fbBuilder.writeListOfStructs(_test4!);
2074 final int? testarrayofstringOffset = _testarrayofstring == null ? null
2075 : fbBuilder.writeList(_testarrayofstring!.map(fbBuilder.writeString).toList());
2076 final int? testarrayoftablesOffset = _testarrayoftables == null ? null
2077 : fbBuilder.writeList(_testarrayoftables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
2078 final int? enemyOffset = _enemy?.getOrCreateOffset(fbBuilder);
2079 final int? testnestedflatbufferOffset = _testnestedflatbuffer == null ? null
2080 : fbBuilder.writeListUint8(_testnestedflatbuffer!);
2081 final int? testemptyOffset = _testempty?.getOrCreateOffset(fbBuilder);
2082 final int? testarrayofboolsOffset = _testarrayofbools == null ? null
2083 : fbBuilder.writeListBool(_testarrayofbools!);
2084 final int? testarrayofstring2Offset = _testarrayofstring2 == null ? null
2085 : fbBuilder.writeList(_testarrayofstring2!.map(fbBuilder.writeString).toList());
2086 final int? testarrayofsortedstructOffset = _testarrayofsortedstruct == null ? null
2087 : fbBuilder.writeListOfStructs(_testarrayofsortedstruct!);
2088 final int? flexOffset = _flex == null ? null
2089 : fbBuilder.writeListUint8(_flex!);
2090 final int? test5Offset = _test5 == null ? null
2091 : fbBuilder.writeListOfStructs(_test5!);
2092 final int? vectorOfLongsOffset = _vectorOfLongs == null ? null
2093 : fbBuilder.writeListInt64(_vectorOfLongs!);
2094 final int? vectorOfDoublesOffset = _vectorOfDoubles == null ? null
2095 : fbBuilder.writeListFloat64(_vectorOfDoubles!);
2096 final int? parentNamespaceTestOffset = _parentNamespaceTest?.getOrCreateOffset(fbBuilder);
2097 final int? vectorOfReferrablesOffset = _vectorOfReferrables == null ? null
2098 : fbBuilder.writeList(_vectorOfReferrables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
2099 final int? vectorOfWeakReferencesOffset = _vectorOfWeakReferences == null ? null
2100 : fbBuilder.writeListUint64(_vectorOfWeakReferences!);
2101 final int? vectorOfStrongReferrablesOffset = _vectorOfStrongReferrables == null ? null
2102 : fbBuilder.writeList(_vectorOfStrongReferrables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
2103 final int? vectorOfCoOwningReferencesOffset = _vectorOfCoOwningReferences == null ? null
2104 : fbBuilder.writeListUint64(_vectorOfCoOwningReferences!);
2105 final int? vectorOfNonOwningReferencesOffset = _vectorOfNonOwningReferences == null ? null
2106 : fbBuilder.writeListUint64(_vectorOfNonOwningReferences!);
2107 final int? anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);
2108 final int? anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);
2109 final int? vectorOfEnumsOffset = _vectorOfEnums == null ? null
2110 : fbBuilder.writeListUint8(_vectorOfEnums!.map((f) => f.value).toList());
2111 final int? testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer == null ? null
2112 : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
2113 final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null ? null
2114 : fbBuilder.writeList(_scalarKeySortedTables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
2115 fbBuilder.startTable(62);
2116 if (_pos != null) {
2117 fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
2118 }
2119 fbBuilder.addInt16(1, _mana);
2120 fbBuilder.addInt16(2, _hp);
2121 fbBuilder.addOffset(3, nameOffset);
2122 fbBuilder.addOffset(5, inventoryOffset);
2123 fbBuilder.addUint8(6, _color?.value);
2124 fbBuilder.addUint8(7, _testType?.value);
2125 fbBuilder.addOffset(8, testOffset);
2126 fbBuilder.addOffset(9, test4Offset);
2127 fbBuilder.addOffset(10, testarrayofstringOffset);
2128 fbBuilder.addOffset(11, testarrayoftablesOffset);
2129 fbBuilder.addOffset(12, enemyOffset);
2130 fbBuilder.addOffset(13, testnestedflatbufferOffset);
2131 fbBuilder.addOffset(14, testemptyOffset);
2132 fbBuilder.addBool(15, _testbool);
2133 fbBuilder.addInt32(16, _testhashs32Fnv1);
2134 fbBuilder.addUint32(17, _testhashu32Fnv1);
2135 fbBuilder.addInt64(18, _testhashs64Fnv1);
2136 fbBuilder.addUint64(19, _testhashu64Fnv1);
2137 fbBuilder.addInt32(20, _testhashs32Fnv1a);
2138 fbBuilder.addUint32(21, _testhashu32Fnv1a);
2139 fbBuilder.addInt64(22, _testhashs64Fnv1a);
2140 fbBuilder.addUint64(23, _testhashu64Fnv1a);
2141 fbBuilder.addOffset(24, testarrayofboolsOffset);
2142 fbBuilder.addFloat32(25, _testf);
2143 fbBuilder.addFloat32(26, _testf2);
2144 fbBuilder.addFloat32(27, _testf3);
2145 fbBuilder.addOffset(28, testarrayofstring2Offset);
2146 fbBuilder.addOffset(29, testarrayofsortedstructOffset);
2147 fbBuilder.addOffset(30, flexOffset);
2148 fbBuilder.addOffset(31, test5Offset);
2149 fbBuilder.addOffset(32, vectorOfLongsOffset);
2150 fbBuilder.addOffset(33, vectorOfDoublesOffset);
2151 fbBuilder.addOffset(34, parentNamespaceTestOffset);
2152 fbBuilder.addOffset(35, vectorOfReferrablesOffset);
2153 fbBuilder.addUint64(36, _singleWeakReference);
2154 fbBuilder.addOffset(37, vectorOfWeakReferencesOffset);
2155 fbBuilder.addOffset(38, vectorOfStrongReferrablesOffset);
2156 fbBuilder.addUint64(39, _coOwningReference);
2157 fbBuilder.addOffset(40, vectorOfCoOwningReferencesOffset);
2158 fbBuilder.addUint64(41, _nonOwningReference);
2159 fbBuilder.addOffset(42, vectorOfNonOwningReferencesOffset);
2160 fbBuilder.addUint8(43, _anyUniqueType?.value);
2161 fbBuilder.addOffset(44, anyUniqueOffset);
2162 fbBuilder.addUint8(45, _anyAmbiguousType?.value);
2163 fbBuilder.addOffset(46, anyAmbiguousOffset);
2164 fbBuilder.addOffset(47, vectorOfEnumsOffset);
2165 fbBuilder.addInt8(48, _signedEnum?.value);
2166 fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
2167 fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
2168 if (_nativeInline != null) {
2169 fbBuilder.addStruct(51, _nativeInline!.finish(fbBuilder));
2170 }
2171 fbBuilder.addUint64(52, _longEnumNonEnumDefault?.value);
2172 fbBuilder.addUint64(53, _longEnumNormalDefault?.value);
2173 fbBuilder.addFloat32(54, _nanDefault);
2174 fbBuilder.addFloat32(55, _infDefault);
2175 fbBuilder.addFloat32(56, _positiveInfDefault);
2176 fbBuilder.addFloat32(57, _infinityDefault);
2177 fbBuilder.addFloat32(58, _positiveInfinityDefault);
2178 fbBuilder.addFloat32(59, _negativeInfDefault);
2179 fbBuilder.addFloat32(60, _negativeInfinityDefault);
2180 fbBuilder.addFloat64(61, _doubleInfDefault);
2181 return fbBuilder.endTable();
2182 }
2183
2184 /// Convenience method to serialize to byte list.
2185 @override
2186 Uint8List toBytes([String? fileIdentifier]) {
2187 final fbBuilder = fb.Builder(deduplicateTables: false);
2188 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
2189 return fbBuilder.buffer;
2190 }
2191}
2192class TypeAliases {
2193 TypeAliases._(this._bc, this._bcOffset);
2194 factory TypeAliases(List<int> bytes) {
2195 final rootRef = fb.BufferContext.fromBytes(bytes);
2196 return reader.read(rootRef, 0);
2197 }
2198
2199 static const fb.Reader<TypeAliases> reader = _TypeAliasesReader();
2200
2201 final fb.BufferContext _bc;
2202 final int _bcOffset;
2203
2204 int get i8 => const fb.Int8Reader().vTableGet(_bc, _bcOffset, 4, 0);
2205 int get u8 => const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 6, 0);
2206 int get i16 => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 0);
2207 int get u16 => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 10, 0);
2208 int get i32 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 12, 0);
2209 int get u32 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 14, 0);
2210 int get i64 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 16, 0);
2211 int get u64 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 18, 0);
2212 double get f32 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 20, 0.0);
2213 double get f64 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 22, 0.0);
2214 List<int>? get v8 => const fb.Int8ListReader().vTableGetNullable(_bc, _bcOffset, 24);
2215 List<double>? get vf64 => const fb.ListReader<double>(fb.Float64Reader()).vTableGetNullable(_bc, _bcOffset, 26);
2216
2217 @override
2218 String toString() {
2219 return 'TypeAliases{i8: ${i8}, u8: ${u8}, i16: ${i16}, u16: ${u16}, i32: ${i32}, u32: ${u32}, i64: ${i64}, u64: ${u64}, f32: ${f32}, f64: ${f64}, v8: ${v8}, vf64: ${vf64}}';
2220 }
2221
2222 TypeAliasesT unpack() => TypeAliasesT(
2223 i8: i8,
2224 u8: u8,
2225 i16: i16,
2226 u16: u16,
2227 i32: i32,
2228 u32: u32,
2229 i64: i64,
2230 u64: u64,
2231 f32: f32,
2232 f64: f64,
2233 v8: const fb.Int8ListReader(lazy: false).vTableGetNullable(_bc, _bcOffset, 24),
2234 vf64: const fb.ListReader<double>(fb.Float64Reader(), lazy: false).vTableGetNullable(_bc, _bcOffset, 26));
2235
2236 static int pack(fb.Builder fbBuilder, TypeAliasesT? object) {
2237 if (object == null) return 0;
2238 return object.pack(fbBuilder);
2239 }
2240}
2241
2242class TypeAliasesT implements fb.Packable {
2243 int i8;
2244 int u8;
2245 int i16;
2246 int u16;
2247 int i32;
2248 int u32;
2249 int i64;
2250 int u64;
2251 double f32;
2252 double f64;
2253 List<int>? v8;
2254 List<double>? vf64;
2255
2256 TypeAliasesT({
2257 this.i8 = 0,
2258 this.u8 = 0,
2259 this.i16 = 0,
2260 this.u16 = 0,
2261 this.i32 = 0,
2262 this.u32 = 0,
2263 this.i64 = 0,
2264 this.u64 = 0,
2265 this.f32 = 0.0,
2266 this.f64 = 0.0,
2267 this.v8,
2268 this.vf64});
2269
2270 @override
2271 int pack(fb.Builder fbBuilder) {
2272 final int? v8Offset = v8 == null ? null
2273 : fbBuilder.writeListInt8(v8!);
2274 final int? vf64Offset = vf64 == null ? null
2275 : fbBuilder.writeListFloat64(vf64!);
2276 fbBuilder.startTable(12);
2277 fbBuilder.addInt8(0, i8);
2278 fbBuilder.addUint8(1, u8);
2279 fbBuilder.addInt16(2, i16);
2280 fbBuilder.addUint16(3, u16);
2281 fbBuilder.addInt32(4, i32);
2282 fbBuilder.addUint32(5, u32);
2283 fbBuilder.addInt64(6, i64);
2284 fbBuilder.addUint64(7, u64);
2285 fbBuilder.addFloat32(8, f32);
2286 fbBuilder.addFloat64(9, f64);
2287 fbBuilder.addOffset(10, v8Offset);
2288 fbBuilder.addOffset(11, vf64Offset);
2289 return fbBuilder.endTable();
2290 }
2291
2292 @override
2293 String toString() {
2294 return 'TypeAliasesT{i8: ${i8}, u8: ${u8}, i16: ${i16}, u16: ${u16}, i32: ${i32}, u32: ${u32}, i64: ${i64}, u64: ${u64}, f32: ${f32}, f64: ${f64}, v8: ${v8}, vf64: ${vf64}}';
2295 }
2296}
2297
2298class _TypeAliasesReader extends fb.TableReader<TypeAliases> {
2299 const _TypeAliasesReader();
2300
2301 @override
2302 TypeAliases createObject(fb.BufferContext bc, int offset) =>
2303 TypeAliases._(bc, offset);
2304}
2305
2306class TypeAliasesBuilder {
2307 TypeAliasesBuilder(this.fbBuilder);
2308
2309 final fb.Builder fbBuilder;
2310
2311 void begin() {
2312 fbBuilder.startTable(12);
2313 }
2314
2315 int addI8(int? i8) {
2316 fbBuilder.addInt8(0, i8);
2317 return fbBuilder.offset;
2318 }
2319 int addU8(int? u8) {
2320 fbBuilder.addUint8(1, u8);
2321 return fbBuilder.offset;
2322 }
2323 int addI16(int? i16) {
2324 fbBuilder.addInt16(2, i16);
2325 return fbBuilder.offset;
2326 }
2327 int addU16(int? u16) {
2328 fbBuilder.addUint16(3, u16);
2329 return fbBuilder.offset;
2330 }
2331 int addI32(int? i32) {
2332 fbBuilder.addInt32(4, i32);
2333 return fbBuilder.offset;
2334 }
2335 int addU32(int? u32) {
2336 fbBuilder.addUint32(5, u32);
2337 return fbBuilder.offset;
2338 }
2339 int addI64(int? i64) {
2340 fbBuilder.addInt64(6, i64);
2341 return fbBuilder.offset;
2342 }
2343 int addU64(int? u64) {
2344 fbBuilder.addUint64(7, u64);
2345 return fbBuilder.offset;
2346 }
2347 int addF32(double? f32) {
2348 fbBuilder.addFloat32(8, f32);
2349 return fbBuilder.offset;
2350 }
2351 int addF64(double? f64) {
2352 fbBuilder.addFloat64(9, f64);
2353 return fbBuilder.offset;
2354 }
2355 int addV8Offset(int? offset) {
2356 fbBuilder.addOffset(10, offset);
2357 return fbBuilder.offset;
2358 }
2359 int addVf64Offset(int? offset) {
2360 fbBuilder.addOffset(11, offset);
2361 return fbBuilder.offset;
2362 }
2363
2364 int finish() {
2365 return fbBuilder.endTable();
2366 }
2367}
2368
2369class TypeAliasesObjectBuilder extends fb.ObjectBuilder {
2370 final int? _i8;
2371 final int? _u8;
2372 final int? _i16;
2373 final int? _u16;
2374 final int? _i32;
2375 final int? _u32;
2376 final int? _i64;
2377 final int? _u64;
2378 final double? _f32;
2379 final double? _f64;
2380 final List<int>? _v8;
2381 final List<double>? _vf64;
2382
2383 TypeAliasesObjectBuilder({
2384 int? i8,
2385 int? u8,
2386 int? i16,
2387 int? u16,
2388 int? i32,
2389 int? u32,
2390 int? i64,
2391 int? u64,
2392 double? f32,
2393 double? f64,
2394 List<int>? v8,
2395 List<double>? vf64,
2396 })
2397 : _i8 = i8,
2398 _u8 = u8,
2399 _i16 = i16,
2400 _u16 = u16,
2401 _i32 = i32,
2402 _u32 = u32,
2403 _i64 = i64,
2404 _u64 = u64,
2405 _f32 = f32,
2406 _f64 = f64,
2407 _v8 = v8,
2408 _vf64 = vf64;
2409
2410 /// Finish building, and store into the [fbBuilder].
2411 @override
2412 int finish(fb.Builder fbBuilder) {
2413 final int? v8Offset = _v8 == null ? null
2414 : fbBuilder.writeListInt8(_v8!);
2415 final int? vf64Offset = _vf64 == null ? null
2416 : fbBuilder.writeListFloat64(_vf64!);
2417 fbBuilder.startTable(12);
2418 fbBuilder.addInt8(0, _i8);
2419 fbBuilder.addUint8(1, _u8);
2420 fbBuilder.addInt16(2, _i16);
2421 fbBuilder.addUint16(3, _u16);
2422 fbBuilder.addInt32(4, _i32);
2423 fbBuilder.addUint32(5, _u32);
2424 fbBuilder.addInt64(6, _i64);
2425 fbBuilder.addUint64(7, _u64);
2426 fbBuilder.addFloat32(8, _f32);
2427 fbBuilder.addFloat64(9, _f64);
2428 fbBuilder.addOffset(10, v8Offset);
2429 fbBuilder.addOffset(11, vf64Offset);
2430 return fbBuilder.endTable();
2431 }
2432
2433 /// Convenience method to serialize to byte list.
2434 @override
2435 Uint8List toBytes([String? fileIdentifier]) {
2436 final fbBuilder = fb.Builder(deduplicateTables: false);
2437 fbBuilder.finish(finish(fbBuilder), fileIdentifier);
2438 return fbBuilder.buffer;
2439 }
2440}
View as plain text