1// automatically generated by the FlatBuffers compiler, do not modify
2// ignore_for_file: unused_import, unused_field, 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
12///  Composite components of Monster color.
13class Color {
14  final int value;
15  const Color._(this.value);
16
17  factory Color.fromValue(int value) {
18    if (value == null) value = 0;
19    if (!values.containsKey(value)) {
20      throw new StateError('Invalid value $value for bit flag enum Color');
21    }
22    return values[value];
23  }
24
25  static bool containsValue(int value) => values.containsKey(value);
26
27  static const Color Red = const Color._(1);
28
29  ///  \brief color Green
30  ///  Green is bit_flag with value (1u << 1)
31  static const Color Green = const Color._(2);
32
33  ///  \brief color Blue (1u << 3)
34  static const Color Blue = const Color._(8);
35  static get values => {1: Red,2: Green,8: Blue,};
36
37  static const fb.Reader<Color> reader = const _ColorReader();
38
39  @override
40  String toString() {
41    return 'Color{value: $value}';
42  }
43}
44
45class _ColorReader extends fb.Reader<Color> {
46  const _ColorReader();
47
48  @override
49  int get size => 1;
50
51  @override
52  Color read(fb.BufferContext bc, int offset) =>
53      new Color.fromValue(const fb.Uint8Reader().read(bc, offset));
54}
55
56class Race {
57  final int value;
58  const Race._(this.value);
59
60  factory Race.fromValue(int value) {
61    if (value == null) value = 0;
62    if (!values.containsKey(value)) {
63      throw new StateError('Invalid value $value for bit flag enum Race');
64    }
65    return values[value];
66  }
67
68  static const int minValue = -1;
69  static const int maxValue = 2;
70  static bool containsValue(int value) => values.containsKey(value);
71
72  static const Race None = const Race._(-1);
73  static const Race Human = const Race._(0);
74  static const Race Dwarf = const Race._(1);
75  static const Race Elf = const Race._(2);
76  static get values => {-1: None,0: Human,1: Dwarf,2: Elf,};
77
78  static const fb.Reader<Race> reader = const _RaceReader();
79
80  @override
81  String toString() {
82    return 'Race{value: $value}';
83  }
84}
85
86class _RaceReader extends fb.Reader<Race> {
87  const _RaceReader();
88
89  @override
90  int get size => 1;
91
92  @override
93  Race read(fb.BufferContext bc, int offset) =>
94      new Race.fromValue(const fb.Int8Reader().read(bc, offset));
95}
96
97class AnyTypeId {
98  final int value;
99  const AnyTypeId._(this.value);
100
101  factory AnyTypeId.fromValue(int value) {
102    if (value == null) value = 0;
103    if (!values.containsKey(value)) {
104      throw new StateError('Invalid value $value for bit flag enum AnyTypeId');
105    }
106    return values[value];
107  }
108
109  static const int minValue = 0;
110  static const int maxValue = 3;
111  static bool containsValue(int value) => values.containsKey(value);
112
113  static const AnyTypeId NONE = const AnyTypeId._(0);
114  static const AnyTypeId Monster = const AnyTypeId._(1);
115  static const AnyTypeId TestSimpleTableWithEnum = const AnyTypeId._(2);
116  static const AnyTypeId MyGame_Example2_Monster = const AnyTypeId._(3);
117  static get values => {0: NONE,1: Monster,2: TestSimpleTableWithEnum,3: MyGame_Example2_Monster,};
118
119  static const fb.Reader<AnyTypeId> reader = const _AnyTypeIdReader();
120
121  @override
122  String toString() {
123    return 'AnyTypeId{value: $value}';
124  }
125}
126
127class _AnyTypeIdReader extends fb.Reader<AnyTypeId> {
128  const _AnyTypeIdReader();
129
130  @override
131  int get size => 1;
132
133  @override
134  AnyTypeId read(fb.BufferContext bc, int offset) =>
135      new AnyTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
136}
137
138class AnyUniqueAliasesTypeId {
139  final int value;
140  const AnyUniqueAliasesTypeId._(this.value);
141
142  factory AnyUniqueAliasesTypeId.fromValue(int value) {
143    if (value == null) value = 0;
144    if (!values.containsKey(value)) {
145      throw new StateError('Invalid value $value for bit flag enum AnyUniqueAliasesTypeId');
146    }
147    return values[value];
148  }
149
150  static const int minValue = 0;
151  static const int maxValue = 3;
152  static bool containsValue(int value) => values.containsKey(value);
153
154  static const AnyUniqueAliasesTypeId NONE = const AnyUniqueAliasesTypeId._(0);
155  static const AnyUniqueAliasesTypeId M = const AnyUniqueAliasesTypeId._(1);
156  static const AnyUniqueAliasesTypeId TS = const AnyUniqueAliasesTypeId._(2);
157  static const AnyUniqueAliasesTypeId M2 = const AnyUniqueAliasesTypeId._(3);
158  static get values => {0: NONE,1: M,2: TS,3: M2,};
159
160  static const fb.Reader<AnyUniqueAliasesTypeId> reader = const _AnyUniqueAliasesTypeIdReader();
161
162  @override
163  String toString() {
164    return 'AnyUniqueAliasesTypeId{value: $value}';
165  }
166}
167
168class _AnyUniqueAliasesTypeIdReader extends fb.Reader<AnyUniqueAliasesTypeId> {
169  const _AnyUniqueAliasesTypeIdReader();
170
171  @override
172  int get size => 1;
173
174  @override
175  AnyUniqueAliasesTypeId read(fb.BufferContext bc, int offset) =>
176      new AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
177}
178
179class AnyAmbiguousAliasesTypeId {
180  final int value;
181  const AnyAmbiguousAliasesTypeId._(this.value);
182
183  factory AnyAmbiguousAliasesTypeId.fromValue(int value) {
184    if (value == null) value = 0;
185    if (!values.containsKey(value)) {
186      throw new StateError('Invalid value $value for bit flag enum AnyAmbiguousAliasesTypeId');
187    }
188    return values[value];
189  }
190
191  static const int minValue = 0;
192  static const int maxValue = 3;
193  static bool containsValue(int value) => values.containsKey(value);
194
195  static const AnyAmbiguousAliasesTypeId NONE = const AnyAmbiguousAliasesTypeId._(0);
196  static const AnyAmbiguousAliasesTypeId M1 = const AnyAmbiguousAliasesTypeId._(1);
197  static const AnyAmbiguousAliasesTypeId M2 = const AnyAmbiguousAliasesTypeId._(2);
198  static const AnyAmbiguousAliasesTypeId M3 = const AnyAmbiguousAliasesTypeId._(3);
199  static get values => {0: NONE,1: M1,2: M2,3: M3,};
200
201  static const fb.Reader<AnyAmbiguousAliasesTypeId> reader = const _AnyAmbiguousAliasesTypeIdReader();
202
203  @override
204  String toString() {
205    return 'AnyAmbiguousAliasesTypeId{value: $value}';
206  }
207}
208
209class _AnyAmbiguousAliasesTypeIdReader extends fb.Reader<AnyAmbiguousAliasesTypeId> {
210  const _AnyAmbiguousAliasesTypeIdReader();
211
212  @override
213  int get size => 1;
214
215  @override
216  AnyAmbiguousAliasesTypeId read(fb.BufferContext bc, int offset) =>
217      new AnyAmbiguousAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
218}
219
220class Test {
221  Test._(this._bc, this._bcOffset);
222
223  static const fb.Reader<Test> reader = const _TestReader();
224
225  final fb.BufferContext _bc;
226  final int _bcOffset;
227
228  int get a => const fb.Int16Reader().read(_bc, _bcOffset + 0);
229  int get b => const fb.Int8Reader().read(_bc, _bcOffset + 2);
230
231  @override
232  String toString() {
233    return 'Test{a: $a, b: $b}';
234  }
235}
236
237class _TestReader extends fb.StructReader<Test> {
238  const _TestReader();
239
240  @override
241  int get size => 4;
242
243  @override
244  Test createObject(fb.BufferContext bc, int offset) =>
245    new Test._(bc, offset);
246}
247
248class TestBuilder {
249  TestBuilder(this.fbBuilder) {
250    assert(fbBuilder != null);
251  }
252
253  final fb.Builder fbBuilder;
254
255  int finish(int a, int b) {
256    fbBuilder.pad(1);
257    fbBuilder.putInt8(b);
258    fbBuilder.putInt16(a);
259    return fbBuilder.offset;
260  }
261
262}
263
264class TestObjectBuilder extends fb.ObjectBuilder {
265  final int _a;
266  final int _b;
267
268  TestObjectBuilder({
269    int a,
270    int b,
271  })
272      : _a = a,
273        _b = b;
274
275  /// Finish building, and store into the [fbBuilder].
276  @override
277  int finish(
278    fb.Builder fbBuilder) {
279    assert(fbBuilder != null);
280
281    fbBuilder.pad(1);
282    fbBuilder.putInt8(_b);
283    fbBuilder.putInt16(_a);
284    return fbBuilder.offset;
285  }
286
287  /// Convenience method to serialize to byte list.
288  @override
289  Uint8List toBytes([String fileIdentifier]) {
290    fb.Builder fbBuilder = new fb.Builder();
291    int offset = finish(fbBuilder);
292    return fbBuilder.finish(offset, fileIdentifier);
293  }
294}
295class TestSimpleTableWithEnum {
296  TestSimpleTableWithEnum._(this._bc, this._bcOffset);
297  factory TestSimpleTableWithEnum(List<int> bytes) {
298    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
299    return reader.read(rootRef, 0);
300  }
301
302  static const fb.Reader<TestSimpleTableWithEnum> reader = const _TestSimpleTableWithEnumReader();
303
304  final fb.BufferContext _bc;
305  final int _bcOffset;
306
307  Color get color => new Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 4, 2));
308
309  @override
310  String toString() {
311    return 'TestSimpleTableWithEnum{color: $color}';
312  }
313}
314
315class _TestSimpleTableWithEnumReader extends fb.TableReader<TestSimpleTableWithEnum> {
316  const _TestSimpleTableWithEnumReader();
317
318  @override
319  TestSimpleTableWithEnum createObject(fb.BufferContext bc, int offset) =>
320    new TestSimpleTableWithEnum._(bc, offset);
321}
322
323class TestSimpleTableWithEnumBuilder {
324  TestSimpleTableWithEnumBuilder(this.fbBuilder) {
325    assert(fbBuilder != null);
326  }
327
328  final fb.Builder fbBuilder;
329
330  void begin() {
331    fbBuilder.startTable();
332  }
333
334  int addColor(Color color) {
335    fbBuilder.addUint8(0, color?.value);
336    return fbBuilder.offset;
337  }
338
339  int finish() {
340    return fbBuilder.endTable();
341  }
342}
343
344class TestSimpleTableWithEnumObjectBuilder extends fb.ObjectBuilder {
345  final Color _color;
346
347  TestSimpleTableWithEnumObjectBuilder({
348    Color color,
349  })
350      : _color = color;
351
352  /// Finish building, and store into the [fbBuilder].
353  @override
354  int finish(
355    fb.Builder fbBuilder) {
356    assert(fbBuilder != null);
357
358    fbBuilder.startTable();
359    fbBuilder.addUint8(0, _color?.value);
360    return fbBuilder.endTable();
361  }
362
363  /// Convenience method to serialize to byte list.
364  @override
365  Uint8List toBytes([String fileIdentifier]) {
366    fb.Builder fbBuilder = new fb.Builder();
367    int offset = finish(fbBuilder);
368    return fbBuilder.finish(offset, fileIdentifier);
369  }
370}
371class Vec3 {
372  Vec3._(this._bc, this._bcOffset);
373
374  static const fb.Reader<Vec3> reader = const _Vec3Reader();
375
376  final fb.BufferContext _bc;
377  final int _bcOffset;
378
379  double get x => const fb.Float32Reader().read(_bc, _bcOffset + 0);
380  double get y => const fb.Float32Reader().read(_bc, _bcOffset + 4);
381  double get z => const fb.Float32Reader().read(_bc, _bcOffset + 8);
382  double get test1 => const fb.Float64Reader().read(_bc, _bcOffset + 16);
383  Color get test2 => new Color.fromValue(const fb.Uint8Reader().read(_bc, _bcOffset + 24));
384  Test get test3 => Test.reader.read(_bc, _bcOffset + 26);
385
386  @override
387  String toString() {
388    return 'Vec3{x: $x, y: $y, z: $z, test1: $test1, test2: $test2, test3: $test3}';
389  }
390}
391
392class _Vec3Reader extends fb.StructReader<Vec3> {
393  const _Vec3Reader();
394
395  @override
396  int get size => 32;
397
398  @override
399  Vec3 createObject(fb.BufferContext bc, int offset) =>
400    new Vec3._(bc, offset);
401}
402
403class Vec3Builder {
404  Vec3Builder(this.fbBuilder) {
405    assert(fbBuilder != null);
406  }
407
408  final fb.Builder fbBuilder;
409
410  int finish(double x, double y, double z, double test1, Color test2, fb.StructBuilder test3) {
411    fbBuilder.pad(2);
412    test3();
413    fbBuilder.pad(1);
414    fbBuilder.putUint8(test2?.value);
415    fbBuilder.putFloat64(test1);
416    fbBuilder.pad(4);
417    fbBuilder.putFloat32(z);
418    fbBuilder.putFloat32(y);
419    fbBuilder.putFloat32(x);
420    return fbBuilder.offset;
421  }
422
423}
424
425class Vec3ObjectBuilder extends fb.ObjectBuilder {
426  final double _x;
427  final double _y;
428  final double _z;
429  final double _test1;
430  final Color _test2;
431  final TestObjectBuilder _test3;
432
433  Vec3ObjectBuilder({
434    double x,
435    double y,
436    double z,
437    double test1,
438    Color test2,
439    TestObjectBuilder test3,
440  })
441      : _x = x,
442        _y = y,
443        _z = z,
444        _test1 = test1,
445        _test2 = test2,
446        _test3 = test3;
447
448  /// Finish building, and store into the [fbBuilder].
449  @override
450  int finish(
451    fb.Builder fbBuilder) {
452    assert(fbBuilder != null);
453
454    fbBuilder.pad(2);
455    _test3.finish(fbBuilder);
456    fbBuilder.pad(1);
457    fbBuilder.putUint8(_test2?.value);
458    fbBuilder.putFloat64(_test1);
459    fbBuilder.pad(4);
460    fbBuilder.putFloat32(_z);
461    fbBuilder.putFloat32(_y);
462    fbBuilder.putFloat32(_x);
463    return fbBuilder.offset;
464  }
465
466  /// Convenience method to serialize to byte list.
467  @override
468  Uint8List toBytes([String fileIdentifier]) {
469    fb.Builder fbBuilder = new fb.Builder();
470    int offset = finish(fbBuilder);
471    return fbBuilder.finish(offset, fileIdentifier);
472  }
473}
474class Ability {
475  Ability._(this._bc, this._bcOffset);
476
477  static const fb.Reader<Ability> reader = const _AbilityReader();
478
479  final fb.BufferContext _bc;
480  final int _bcOffset;
481
482  int get id => const fb.Uint32Reader().read(_bc, _bcOffset + 0);
483  int get distance => const fb.Uint32Reader().read(_bc, _bcOffset + 4);
484
485  @override
486  String toString() {
487    return 'Ability{id: $id, distance: $distance}';
488  }
489}
490
491class _AbilityReader extends fb.StructReader<Ability> {
492  const _AbilityReader();
493
494  @override
495  int get size => 8;
496
497  @override
498  Ability createObject(fb.BufferContext bc, int offset) =>
499    new Ability._(bc, offset);
500}
501
502class AbilityBuilder {
503  AbilityBuilder(this.fbBuilder) {
504    assert(fbBuilder != null);
505  }
506
507  final fb.Builder fbBuilder;
508
509  int finish(int id, int distance) {
510    fbBuilder.putUint32(distance);
511    fbBuilder.putUint32(id);
512    return fbBuilder.offset;
513  }
514
515}
516
517class AbilityObjectBuilder extends fb.ObjectBuilder {
518  final int _id;
519  final int _distance;
520
521  AbilityObjectBuilder({
522    int id,
523    int distance,
524  })
525      : _id = id,
526        _distance = distance;
527
528  /// Finish building, and store into the [fbBuilder].
529  @override
530  int finish(
531    fb.Builder fbBuilder) {
532    assert(fbBuilder != null);
533
534    fbBuilder.putUint32(_distance);
535    fbBuilder.putUint32(_id);
536    return fbBuilder.offset;
537  }
538
539  /// Convenience method to serialize to byte list.
540  @override
541  Uint8List toBytes([String fileIdentifier]) {
542    fb.Builder fbBuilder = new fb.Builder();
543    int offset = finish(fbBuilder);
544    return fbBuilder.finish(offset, fileIdentifier);
545  }
546}
547class Stat {
548  Stat._(this._bc, this._bcOffset);
549  factory Stat(List<int> bytes) {
550    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
551    return reader.read(rootRef, 0);
552  }
553
554  static const fb.Reader<Stat> reader = const _StatReader();
555
556  final fb.BufferContext _bc;
557  final int _bcOffset;
558
559  String get id => const fb.StringReader().vTableGet(_bc, _bcOffset, 4, null);
560  int get val => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 6, 0);
561  int get count => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 8, 0);
562
563  @override
564  String toString() {
565    return 'Stat{id: $id, val: $val, count: $count}';
566  }
567}
568
569class _StatReader extends fb.TableReader<Stat> {
570  const _StatReader();
571
572  @override
573  Stat createObject(fb.BufferContext bc, int offset) =>
574    new Stat._(bc, offset);
575}
576
577class StatBuilder {
578  StatBuilder(this.fbBuilder) {
579    assert(fbBuilder != null);
580  }
581
582  final fb.Builder fbBuilder;
583
584  void begin() {
585    fbBuilder.startTable();
586  }
587
588  int addIdOffset(int offset) {
589    fbBuilder.addOffset(0, offset);
590    return fbBuilder.offset;
591  }
592  int addVal(int val) {
593    fbBuilder.addInt64(1, val);
594    return fbBuilder.offset;
595  }
596  int addCount(int count) {
597    fbBuilder.addUint16(2, count);
598    return fbBuilder.offset;
599  }
600
601  int finish() {
602    return fbBuilder.endTable();
603  }
604}
605
606class StatObjectBuilder extends fb.ObjectBuilder {
607  final String _id;
608  final int _val;
609  final int _count;
610
611  StatObjectBuilder({
612    String id,
613    int val,
614    int count,
615  })
616      : _id = id,
617        _val = val,
618        _count = count;
619
620  /// Finish building, and store into the [fbBuilder].
621  @override
622  int finish(
623    fb.Builder fbBuilder) {
624    assert(fbBuilder != null);
625    final int idOffset = fbBuilder.writeString(_id);
626
627    fbBuilder.startTable();
628    if (idOffset != null) {
629      fbBuilder.addOffset(0, idOffset);
630    }
631    fbBuilder.addInt64(1, _val);
632    fbBuilder.addUint16(2, _count);
633    return fbBuilder.endTable();
634  }
635
636  /// Convenience method to serialize to byte list.
637  @override
638  Uint8List toBytes([String fileIdentifier]) {
639    fb.Builder fbBuilder = new fb.Builder();
640    int offset = finish(fbBuilder);
641    return fbBuilder.finish(offset, fileIdentifier);
642  }
643}
644class Referrable {
645  Referrable._(this._bc, this._bcOffset);
646  factory Referrable(List<int> bytes) {
647    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
648    return reader.read(rootRef, 0);
649  }
650
651  static const fb.Reader<Referrable> reader = const _ReferrableReader();
652
653  final fb.BufferContext _bc;
654  final int _bcOffset;
655
656  int get id => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 4, 0);
657
658  @override
659  String toString() {
660    return 'Referrable{id: $id}';
661  }
662}
663
664class _ReferrableReader extends fb.TableReader<Referrable> {
665  const _ReferrableReader();
666
667  @override
668  Referrable createObject(fb.BufferContext bc, int offset) =>
669    new Referrable._(bc, offset);
670}
671
672class ReferrableBuilder {
673  ReferrableBuilder(this.fbBuilder) {
674    assert(fbBuilder != null);
675  }
676
677  final fb.Builder fbBuilder;
678
679  void begin() {
680    fbBuilder.startTable();
681  }
682
683  int addId(int id) {
684    fbBuilder.addUint64(0, id);
685    return fbBuilder.offset;
686  }
687
688  int finish() {
689    return fbBuilder.endTable();
690  }
691}
692
693class ReferrableObjectBuilder extends fb.ObjectBuilder {
694  final int _id;
695
696  ReferrableObjectBuilder({
697    int id,
698  })
699      : _id = id;
700
701  /// Finish building, and store into the [fbBuilder].
702  @override
703  int finish(
704    fb.Builder fbBuilder) {
705    assert(fbBuilder != null);
706
707    fbBuilder.startTable();
708    fbBuilder.addUint64(0, _id);
709    return fbBuilder.endTable();
710  }
711
712  /// Convenience method to serialize to byte list.
713  @override
714  Uint8List toBytes([String fileIdentifier]) {
715    fb.Builder fbBuilder = new fb.Builder();
716    int offset = finish(fbBuilder);
717    return fbBuilder.finish(offset, fileIdentifier);
718  }
719}
720///  an example documentation comment: "monster object"
721class Monster {
722  Monster._(this._bc, this._bcOffset);
723  factory Monster(List<int> bytes) {
724    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
725    return reader.read(rootRef, 0);
726  }
727
728  static const fb.Reader<Monster> reader = const _MonsterReader();
729
730  final fb.BufferContext _bc;
731  final int _bcOffset;
732
733  Vec3 get pos => Vec3.reader.vTableGet(_bc, _bcOffset, 4, null);
734  int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);
735  int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);
736  String get name => const fb.StringReader().vTableGet(_bc, _bcOffset, 10, null);
737  List<int> get inventory => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 14, null);
738  Color get color => new Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));
739  AnyTypeId get testType => new AnyTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 18, 0));
740  dynamic get test {
741    switch (testType?.value) {
742      case 1: return Monster.reader.vTableGet(_bc, _bcOffset, 20, null);
743      case 2: return TestSimpleTableWithEnum.reader.vTableGet(_bc, _bcOffset, 20, null);
744      case 3: return my_game_example2.Monster.reader.vTableGet(_bc, _bcOffset, 20, null);
745      default: return null;
746    }
747  }
748  List<Test> get test4 => const fb.ListReader<Test>(Test.reader).vTableGet(_bc, _bcOffset, 22, null);
749  List<String> get testarrayofstring => const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bc, _bcOffset, 24, null);
750  ///  an example documentation comment: this will end up in the generated code
751  ///  multiline too
752  List<Monster> get testarrayoftables => const fb.ListReader<Monster>(Monster.reader).vTableGet(_bc, _bcOffset, 26, null);
753  Monster get enemy => Monster.reader.vTableGet(_bc, _bcOffset, 28, null);
754  List<int> get testnestedflatbuffer => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 30, null);
755  Stat get testempty => Stat.reader.vTableGet(_bc, _bcOffset, 32, null);
756  bool get testbool => const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);
757  int get testhashs32Fnv1 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 36, 0);
758  int get testhashu32Fnv1 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 38, 0);
759  int get testhashs64Fnv1 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 40, 0);
760  int get testhashu64Fnv1 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 42, 0);
761  int get testhashs32Fnv1a => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 44, 0);
762  int get testhashu32Fnv1a => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 46, 0);
763  int get testhashs64Fnv1a => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 48, 0);
764  int get testhashu64Fnv1a => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);
765  List<bool> get testarrayofbools => const fb.ListReader<bool>(const fb.BoolReader()).vTableGet(_bc, _bcOffset, 52, null);
766  double get testf => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);
767  double get testf2 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 56, 3.0);
768  double get testf3 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);
769  List<String> get testarrayofstring2 => const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bc, _bcOffset, 60, null);
770  List<Ability> get testarrayofsortedstruct => const fb.ListReader<Ability>(Ability.reader).vTableGet(_bc, _bcOffset, 62, null);
771  List<int> get flex => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 64, null);
772  List<Test> get test5 => const fb.ListReader<Test>(Test.reader).vTableGet(_bc, _bcOffset, 66, null);
773  List<int> get vectorOfLongs => const fb.ListReader<int>(const fb.Int64Reader()).vTableGet(_bc, _bcOffset, 68, null);
774  List<double> get vectorOfDoubles => const fb.ListReader<double>(const fb.Float64Reader()).vTableGet(_bc, _bcOffset, 70, null);
775  my_game.InParentNamespace get parentNamespaceTest => my_game.InParentNamespace.reader.vTableGet(_bc, _bcOffset, 72, null);
776  List<Referrable> get vectorOfReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGet(_bc, _bcOffset, 74, null);
777  int get singleWeakReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);
778  List<int> get vectorOfWeakReferences => const fb.ListReader<int>(const fb.Uint64Reader()).vTableGet(_bc, _bcOffset, 78, null);
779  List<Referrable> get vectorOfStrongReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGet(_bc, _bcOffset, 80, null);
780  int get coOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);
781  List<int> get vectorOfCoOwningReferences => const fb.ListReader<int>(const fb.Uint64Reader()).vTableGet(_bc, _bcOffset, 84, null);
782  int get nonOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);
783  List<int> get vectorOfNonOwningReferences => const fb.ListReader<int>(const fb.Uint64Reader()).vTableGet(_bc, _bcOffset, 88, null);
784  AnyUniqueAliasesTypeId get anyUniqueType => new AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 90, 0));
785  dynamic get anyUnique {
786    switch (anyUniqueType?.value) {
787      case 1: return M.reader.vTableGet(_bc, _bcOffset, 92, null);
788      case 2: return TS.reader.vTableGet(_bc, _bcOffset, 92, null);
789      case 3: return M2.reader.vTableGet(_bc, _bcOffset, 92, null);
790      default: return null;
791    }
792  }
793  AnyAmbiguousAliasesTypeId get anyAmbiguousType => new AnyAmbiguousAliasesTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 94, 0));
794  dynamic get anyAmbiguous {
795    switch (anyAmbiguousType?.value) {
796      case 1: return M1.reader.vTableGet(_bc, _bcOffset, 96, null);
797      case 2: return M2.reader.vTableGet(_bc, _bcOffset, 96, null);
798      case 3: return M3.reader.vTableGet(_bc, _bcOffset, 96, null);
799      default: return null;
800    }
801  }
802  List<Color> get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGet(_bc, _bcOffset, 98, null);
803  Race get signedEnum => new Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
804
805  @override
806  String toString() {
807    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}';
808  }
809}
810
811class _MonsterReader extends fb.TableReader<Monster> {
812  const _MonsterReader();
813
814  @override
815  Monster createObject(fb.BufferContext bc, int offset) =>
816    new Monster._(bc, offset);
817}
818
819class MonsterBuilder {
820  MonsterBuilder(this.fbBuilder) {
821    assert(fbBuilder != null);
822  }
823
824  final fb.Builder fbBuilder;
825
826  void begin() {
827    fbBuilder.startTable();
828  }
829
830  int addPos(int offset) {
831    fbBuilder.addStruct(0, offset);
832    return fbBuilder.offset;
833  }
834  int addMana(int mana) {
835    fbBuilder.addInt16(1, mana);
836    return fbBuilder.offset;
837  }
838  int addHp(int hp) {
839    fbBuilder.addInt16(2, hp);
840    return fbBuilder.offset;
841  }
842  int addNameOffset(int offset) {
843    fbBuilder.addOffset(3, offset);
844    return fbBuilder.offset;
845  }
846  int addInventoryOffset(int offset) {
847    fbBuilder.addOffset(5, offset);
848    return fbBuilder.offset;
849  }
850  int addColor(Color color) {
851    fbBuilder.addUint8(6, color?.value);
852    return fbBuilder.offset;
853  }
854  int addTestType(AnyTypeId testType) {
855    fbBuilder.addUint8(7, testType?.value);
856    return fbBuilder.offset;
857  }
858  int addTestOffset(int offset) {
859    fbBuilder.addOffset(8, offset);
860    return fbBuilder.offset;
861  }
862  int addTest4Offset(int offset) {
863    fbBuilder.addOffset(9, offset);
864    return fbBuilder.offset;
865  }
866  int addTestarrayofstringOffset(int offset) {
867    fbBuilder.addOffset(10, offset);
868    return fbBuilder.offset;
869  }
870  int addTestarrayoftablesOffset(int offset) {
871    fbBuilder.addOffset(11, offset);
872    return fbBuilder.offset;
873  }
874  int addEnemyOffset(int offset) {
875    fbBuilder.addOffset(12, offset);
876    return fbBuilder.offset;
877  }
878  int addTestnestedflatbufferOffset(int offset) {
879    fbBuilder.addOffset(13, offset);
880    return fbBuilder.offset;
881  }
882  int addTestemptyOffset(int offset) {
883    fbBuilder.addOffset(14, offset);
884    return fbBuilder.offset;
885  }
886  int addTestbool(bool testbool) {
887    fbBuilder.addBool(15, testbool);
888    return fbBuilder.offset;
889  }
890  int addTesthashs32Fnv1(int testhashs32Fnv1) {
891    fbBuilder.addInt32(16, testhashs32Fnv1);
892    return fbBuilder.offset;
893  }
894  int addTesthashu32Fnv1(int testhashu32Fnv1) {
895    fbBuilder.addUint32(17, testhashu32Fnv1);
896    return fbBuilder.offset;
897  }
898  int addTesthashs64Fnv1(int testhashs64Fnv1) {
899    fbBuilder.addInt64(18, testhashs64Fnv1);
900    return fbBuilder.offset;
901  }
902  int addTesthashu64Fnv1(int testhashu64Fnv1) {
903    fbBuilder.addUint64(19, testhashu64Fnv1);
904    return fbBuilder.offset;
905  }
906  int addTesthashs32Fnv1a(int testhashs32Fnv1a) {
907    fbBuilder.addInt32(20, testhashs32Fnv1a);
908    return fbBuilder.offset;
909  }
910  int addTesthashu32Fnv1a(int testhashu32Fnv1a) {
911    fbBuilder.addUint32(21, testhashu32Fnv1a);
912    return fbBuilder.offset;
913  }
914  int addTesthashs64Fnv1a(int testhashs64Fnv1a) {
915    fbBuilder.addInt64(22, testhashs64Fnv1a);
916    return fbBuilder.offset;
917  }
918  int addTesthashu64Fnv1a(int testhashu64Fnv1a) {
919    fbBuilder.addUint64(23, testhashu64Fnv1a);
920    return fbBuilder.offset;
921  }
922  int addTestarrayofboolsOffset(int offset) {
923    fbBuilder.addOffset(24, offset);
924    return fbBuilder.offset;
925  }
926  int addTestf(double testf) {
927    fbBuilder.addFloat32(25, testf);
928    return fbBuilder.offset;
929  }
930  int addTestf2(double testf2) {
931    fbBuilder.addFloat32(26, testf2);
932    return fbBuilder.offset;
933  }
934  int addTestf3(double testf3) {
935    fbBuilder.addFloat32(27, testf3);
936    return fbBuilder.offset;
937  }
938  int addTestarrayofstring2Offset(int offset) {
939    fbBuilder.addOffset(28, offset);
940    return fbBuilder.offset;
941  }
942  int addTestarrayofsortedstructOffset(int offset) {
943    fbBuilder.addOffset(29, offset);
944    return fbBuilder.offset;
945  }
946  int addFlexOffset(int offset) {
947    fbBuilder.addOffset(30, offset);
948    return fbBuilder.offset;
949  }
950  int addTest5Offset(int offset) {
951    fbBuilder.addOffset(31, offset);
952    return fbBuilder.offset;
953  }
954  int addVectorOfLongsOffset(int offset) {
955    fbBuilder.addOffset(32, offset);
956    return fbBuilder.offset;
957  }
958  int addVectorOfDoublesOffset(int offset) {
959    fbBuilder.addOffset(33, offset);
960    return fbBuilder.offset;
961  }
962  int addParentNamespaceTestOffset(int offset) {
963    fbBuilder.addOffset(34, offset);
964    return fbBuilder.offset;
965  }
966  int addVectorOfReferrablesOffset(int offset) {
967    fbBuilder.addOffset(35, offset);
968    return fbBuilder.offset;
969  }
970  int addSingleWeakReference(int singleWeakReference) {
971    fbBuilder.addUint64(36, singleWeakReference);
972    return fbBuilder.offset;
973  }
974  int addVectorOfWeakReferencesOffset(int offset) {
975    fbBuilder.addOffset(37, offset);
976    return fbBuilder.offset;
977  }
978  int addVectorOfStrongReferrablesOffset(int offset) {
979    fbBuilder.addOffset(38, offset);
980    return fbBuilder.offset;
981  }
982  int addCoOwningReference(int coOwningReference) {
983    fbBuilder.addUint64(39, coOwningReference);
984    return fbBuilder.offset;
985  }
986  int addVectorOfCoOwningReferencesOffset(int offset) {
987    fbBuilder.addOffset(40, offset);
988    return fbBuilder.offset;
989  }
990  int addNonOwningReference(int nonOwningReference) {
991    fbBuilder.addUint64(41, nonOwningReference);
992    return fbBuilder.offset;
993  }
994  int addVectorOfNonOwningReferencesOffset(int offset) {
995    fbBuilder.addOffset(42, offset);
996    return fbBuilder.offset;
997  }
998  int addAnyUniqueType(AnyUniqueAliasesTypeId anyUniqueType) {
999    fbBuilder.addUint8(43, anyUniqueType?.value);
1000    return fbBuilder.offset;
1001  }
1002  int addAnyUniqueOffset(int offset) {
1003    fbBuilder.addOffset(44, offset);
1004    return fbBuilder.offset;
1005  }
1006  int addAnyAmbiguousType(AnyAmbiguousAliasesTypeId anyAmbiguousType) {
1007    fbBuilder.addUint8(45, anyAmbiguousType?.value);
1008    return fbBuilder.offset;
1009  }
1010  int addAnyAmbiguousOffset(int offset) {
1011    fbBuilder.addOffset(46, offset);
1012    return fbBuilder.offset;
1013  }
1014  int addVectorOfEnumsOffset(int offset) {
1015    fbBuilder.addOffset(47, offset);
1016    return fbBuilder.offset;
1017  }
1018  int addSignedEnum(Race signedEnum) {
1019    fbBuilder.addInt8(48, signedEnum?.value);
1020    return fbBuilder.offset;
1021  }
1022
1023  int finish() {
1024    return fbBuilder.endTable();
1025  }
1026}
1027
1028class MonsterObjectBuilder extends fb.ObjectBuilder {
1029  final Vec3ObjectBuilder _pos;
1030  final int _mana;
1031  final int _hp;
1032  final String _name;
1033  final List<int> _inventory;
1034  final Color _color;
1035  final AnyTypeId _testType;
1036  final dynamic _test;
1037  final List<TestObjectBuilder> _test4;
1038  final List<String> _testarrayofstring;
1039  final List<MonsterObjectBuilder> _testarrayoftables;
1040  final MonsterObjectBuilder _enemy;
1041  final List<int> _testnestedflatbuffer;
1042  final StatObjectBuilder _testempty;
1043  final bool _testbool;
1044  final int _testhashs32Fnv1;
1045  final int _testhashu32Fnv1;
1046  final int _testhashs64Fnv1;
1047  final int _testhashu64Fnv1;
1048  final int _testhashs32Fnv1a;
1049  final int _testhashu32Fnv1a;
1050  final int _testhashs64Fnv1a;
1051  final int _testhashu64Fnv1a;
1052  final List<bool> _testarrayofbools;
1053  final double _testf;
1054  final double _testf2;
1055  final double _testf3;
1056  final List<String> _testarrayofstring2;
1057  final List<AbilityObjectBuilder> _testarrayofsortedstruct;
1058  final List<int> _flex;
1059  final List<TestObjectBuilder> _test5;
1060  final List<int> _vectorOfLongs;
1061  final List<double> _vectorOfDoubles;
1062  final my_game.InParentNamespaceObjectBuilder _parentNamespaceTest;
1063  final List<ReferrableObjectBuilder> _vectorOfReferrables;
1064  final int _singleWeakReference;
1065  final List<int> _vectorOfWeakReferences;
1066  final List<ReferrableObjectBuilder> _vectorOfStrongReferrables;
1067  final int _coOwningReference;
1068  final List<int> _vectorOfCoOwningReferences;
1069  final int _nonOwningReference;
1070  final List<int> _vectorOfNonOwningReferences;
1071  final AnyUniqueAliasesTypeId _anyUniqueType;
1072  final dynamic _anyUnique;
1073  final AnyAmbiguousAliasesTypeId _anyAmbiguousType;
1074  final dynamic _anyAmbiguous;
1075  final List<Color> _vectorOfEnums;
1076  final Race _signedEnum;
1077
1078  MonsterObjectBuilder({
1079    Vec3ObjectBuilder pos,
1080    int mana,
1081    int hp,
1082    String name,
1083    List<int> inventory,
1084    Color color,
1085    AnyTypeId testType,
1086    dynamic test,
1087    List<TestObjectBuilder> test4,
1088    List<String> testarrayofstring,
1089    List<MonsterObjectBuilder> testarrayoftables,
1090    MonsterObjectBuilder enemy,
1091    List<int> testnestedflatbuffer,
1092    StatObjectBuilder testempty,
1093    bool testbool,
1094    int testhashs32Fnv1,
1095    int testhashu32Fnv1,
1096    int testhashs64Fnv1,
1097    int testhashu64Fnv1,
1098    int testhashs32Fnv1a,
1099    int testhashu32Fnv1a,
1100    int testhashs64Fnv1a,
1101    int testhashu64Fnv1a,
1102    List<bool> testarrayofbools,
1103    double testf,
1104    double testf2,
1105    double testf3,
1106    List<String> testarrayofstring2,
1107    List<AbilityObjectBuilder> testarrayofsortedstruct,
1108    List<int> flex,
1109    List<TestObjectBuilder> test5,
1110    List<int> vectorOfLongs,
1111    List<double> vectorOfDoubles,
1112    my_game.InParentNamespaceObjectBuilder parentNamespaceTest,
1113    List<ReferrableObjectBuilder> vectorOfReferrables,
1114    int singleWeakReference,
1115    List<int> vectorOfWeakReferences,
1116    List<ReferrableObjectBuilder> vectorOfStrongReferrables,
1117    int coOwningReference,
1118    List<int> vectorOfCoOwningReferences,
1119    int nonOwningReference,
1120    List<int> vectorOfNonOwningReferences,
1121    AnyUniqueAliasesTypeId anyUniqueType,
1122    dynamic anyUnique,
1123    AnyAmbiguousAliasesTypeId anyAmbiguousType,
1124    dynamic anyAmbiguous,
1125    List<Color> vectorOfEnums,
1126    Race signedEnum,
1127  })
1128      : _pos = pos,
1129        _mana = mana,
1130        _hp = hp,
1131        _name = name,
1132        _inventory = inventory,
1133        _color = color,
1134        _testType = testType,
1135        _test = test,
1136        _test4 = test4,
1137        _testarrayofstring = testarrayofstring,
1138        _testarrayoftables = testarrayoftables,
1139        _enemy = enemy,
1140        _testnestedflatbuffer = testnestedflatbuffer,
1141        _testempty = testempty,
1142        _testbool = testbool,
1143        _testhashs32Fnv1 = testhashs32Fnv1,
1144        _testhashu32Fnv1 = testhashu32Fnv1,
1145        _testhashs64Fnv1 = testhashs64Fnv1,
1146        _testhashu64Fnv1 = testhashu64Fnv1,
1147        _testhashs32Fnv1a = testhashs32Fnv1a,
1148        _testhashu32Fnv1a = testhashu32Fnv1a,
1149        _testhashs64Fnv1a = testhashs64Fnv1a,
1150        _testhashu64Fnv1a = testhashu64Fnv1a,
1151        _testarrayofbools = testarrayofbools,
1152        _testf = testf,
1153        _testf2 = testf2,
1154        _testf3 = testf3,
1155        _testarrayofstring2 = testarrayofstring2,
1156        _testarrayofsortedstruct = testarrayofsortedstruct,
1157        _flex = flex,
1158        _test5 = test5,
1159        _vectorOfLongs = vectorOfLongs,
1160        _vectorOfDoubles = vectorOfDoubles,
1161        _parentNamespaceTest = parentNamespaceTest,
1162        _vectorOfReferrables = vectorOfReferrables,
1163        _singleWeakReference = singleWeakReference,
1164        _vectorOfWeakReferences = vectorOfWeakReferences,
1165        _vectorOfStrongReferrables = vectorOfStrongReferrables,
1166        _coOwningReference = coOwningReference,
1167        _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
1168        _nonOwningReference = nonOwningReference,
1169        _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
1170        _anyUniqueType = anyUniqueType,
1171        _anyUnique = anyUnique,
1172        _anyAmbiguousType = anyAmbiguousType,
1173        _anyAmbiguous = anyAmbiguous,
1174        _vectorOfEnums = vectorOfEnums,
1175        _signedEnum = signedEnum;
1176
1177  /// Finish building, and store into the [fbBuilder].
1178  @override
1179  int finish(
1180    fb.Builder fbBuilder) {
1181    assert(fbBuilder != null);
1182    final int nameOffset = fbBuilder.writeString(_name);
1183    final int inventoryOffset = _inventory?.isNotEmpty == true
1184        ? fbBuilder.writeListUint8(_inventory)
1185        : null;
1186    final int testOffset = _test?.getOrCreateOffset(fbBuilder);
1187    final int test4Offset = _test4?.isNotEmpty == true
1188        ? fbBuilder.writeListOfStructs(_test4)
1189        : null;
1190    final int testarrayofstringOffset = _testarrayofstring?.isNotEmpty == true
1191        ? fbBuilder.writeList(_testarrayofstring.map((b) => fbBuilder.writeString(b)).toList())
1192        : null;
1193    final int testarrayoftablesOffset = _testarrayoftables?.isNotEmpty == true
1194        ? fbBuilder.writeList(_testarrayoftables.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
1195        : null;
1196    final int enemyOffset = _enemy?.getOrCreateOffset(fbBuilder);
1197    final int testnestedflatbufferOffset = _testnestedflatbuffer?.isNotEmpty == true
1198        ? fbBuilder.writeListUint8(_testnestedflatbuffer)
1199        : null;
1200    final int testemptyOffset = _testempty?.getOrCreateOffset(fbBuilder);
1201    final int testarrayofboolsOffset = _testarrayofbools?.isNotEmpty == true
1202        ? fbBuilder.writeListBool(_testarrayofbools)
1203        : null;
1204    final int testarrayofstring2Offset = _testarrayofstring2?.isNotEmpty == true
1205        ? fbBuilder.writeList(_testarrayofstring2.map((b) => fbBuilder.writeString(b)).toList())
1206        : null;
1207    final int testarrayofsortedstructOffset = _testarrayofsortedstruct?.isNotEmpty == true
1208        ? fbBuilder.writeListOfStructs(_testarrayofsortedstruct)
1209        : null;
1210    final int flexOffset = _flex?.isNotEmpty == true
1211        ? fbBuilder.writeListUint8(_flex)
1212        : null;
1213    final int test5Offset = _test5?.isNotEmpty == true
1214        ? fbBuilder.writeListOfStructs(_test5)
1215        : null;
1216    final int vectorOfLongsOffset = _vectorOfLongs?.isNotEmpty == true
1217        ? fbBuilder.writeListInt64(_vectorOfLongs)
1218        : null;
1219    final int vectorOfDoublesOffset = _vectorOfDoubles?.isNotEmpty == true
1220        ? fbBuilder.writeListFloat64(_vectorOfDoubles)
1221        : null;
1222    final int parentNamespaceTestOffset = _parentNamespaceTest?.getOrCreateOffset(fbBuilder);
1223    final int vectorOfReferrablesOffset = _vectorOfReferrables?.isNotEmpty == true
1224        ? fbBuilder.writeList(_vectorOfReferrables.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
1225        : null;
1226    final int vectorOfWeakReferencesOffset = _vectorOfWeakReferences?.isNotEmpty == true
1227        ? fbBuilder.writeListUint64(_vectorOfWeakReferences)
1228        : null;
1229    final int vectorOfStrongReferrablesOffset = _vectorOfStrongReferrables?.isNotEmpty == true
1230        ? fbBuilder.writeList(_vectorOfStrongReferrables.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
1231        : null;
1232    final int vectorOfCoOwningReferencesOffset = _vectorOfCoOwningReferences?.isNotEmpty == true
1233        ? fbBuilder.writeListUint64(_vectorOfCoOwningReferences)
1234        : null;
1235    final int vectorOfNonOwningReferencesOffset = _vectorOfNonOwningReferences?.isNotEmpty == true
1236        ? fbBuilder.writeListUint64(_vectorOfNonOwningReferences)
1237        : null;
1238    final int anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);
1239    final int anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);
1240    final int vectorOfEnumsOffset = _vectorOfEnums?.isNotEmpty == true
1241        ? fbBuilder.writeListUint8(_vectorOfEnums.map((f) => f.value))
1242        : null;
1243
1244    fbBuilder.startTable();
1245    if (_pos != null) {
1246      fbBuilder.addStruct(0, _pos.finish(fbBuilder));
1247    }
1248    fbBuilder.addInt16(1, _mana);
1249    fbBuilder.addInt16(2, _hp);
1250    if (nameOffset != null) {
1251      fbBuilder.addOffset(3, nameOffset);
1252    }
1253    if (inventoryOffset != null) {
1254      fbBuilder.addOffset(5, inventoryOffset);
1255    }
1256    fbBuilder.addUint8(6, _color?.value);
1257    fbBuilder.addUint8(7, _testType?.value);
1258    if (testOffset != null) {
1259      fbBuilder.addOffset(8, testOffset);
1260    }
1261    if (test4Offset != null) {
1262      fbBuilder.addOffset(9, test4Offset);
1263    }
1264    if (testarrayofstringOffset != null) {
1265      fbBuilder.addOffset(10, testarrayofstringOffset);
1266    }
1267    if (testarrayoftablesOffset != null) {
1268      fbBuilder.addOffset(11, testarrayoftablesOffset);
1269    }
1270    if (enemyOffset != null) {
1271      fbBuilder.addOffset(12, enemyOffset);
1272    }
1273    if (testnestedflatbufferOffset != null) {
1274      fbBuilder.addOffset(13, testnestedflatbufferOffset);
1275    }
1276    if (testemptyOffset != null) {
1277      fbBuilder.addOffset(14, testemptyOffset);
1278    }
1279    fbBuilder.addBool(15, _testbool);
1280    fbBuilder.addInt32(16, _testhashs32Fnv1);
1281    fbBuilder.addUint32(17, _testhashu32Fnv1);
1282    fbBuilder.addInt64(18, _testhashs64Fnv1);
1283    fbBuilder.addUint64(19, _testhashu64Fnv1);
1284    fbBuilder.addInt32(20, _testhashs32Fnv1a);
1285    fbBuilder.addUint32(21, _testhashu32Fnv1a);
1286    fbBuilder.addInt64(22, _testhashs64Fnv1a);
1287    fbBuilder.addUint64(23, _testhashu64Fnv1a);
1288    if (testarrayofboolsOffset != null) {
1289      fbBuilder.addOffset(24, testarrayofboolsOffset);
1290    }
1291    fbBuilder.addFloat32(25, _testf);
1292    fbBuilder.addFloat32(26, _testf2);
1293    fbBuilder.addFloat32(27, _testf3);
1294    if (testarrayofstring2Offset != null) {
1295      fbBuilder.addOffset(28, testarrayofstring2Offset);
1296    }
1297    if (testarrayofsortedstructOffset != null) {
1298      fbBuilder.addOffset(29, testarrayofsortedstructOffset);
1299    }
1300    if (flexOffset != null) {
1301      fbBuilder.addOffset(30, flexOffset);
1302    }
1303    if (test5Offset != null) {
1304      fbBuilder.addOffset(31, test5Offset);
1305    }
1306    if (vectorOfLongsOffset != null) {
1307      fbBuilder.addOffset(32, vectorOfLongsOffset);
1308    }
1309    if (vectorOfDoublesOffset != null) {
1310      fbBuilder.addOffset(33, vectorOfDoublesOffset);
1311    }
1312    if (parentNamespaceTestOffset != null) {
1313      fbBuilder.addOffset(34, parentNamespaceTestOffset);
1314    }
1315    if (vectorOfReferrablesOffset != null) {
1316      fbBuilder.addOffset(35, vectorOfReferrablesOffset);
1317    }
1318    fbBuilder.addUint64(36, _singleWeakReference);
1319    if (vectorOfWeakReferencesOffset != null) {
1320      fbBuilder.addOffset(37, vectorOfWeakReferencesOffset);
1321    }
1322    if (vectorOfStrongReferrablesOffset != null) {
1323      fbBuilder.addOffset(38, vectorOfStrongReferrablesOffset);
1324    }
1325    fbBuilder.addUint64(39, _coOwningReference);
1326    if (vectorOfCoOwningReferencesOffset != null) {
1327      fbBuilder.addOffset(40, vectorOfCoOwningReferencesOffset);
1328    }
1329    fbBuilder.addUint64(41, _nonOwningReference);
1330    if (vectorOfNonOwningReferencesOffset != null) {
1331      fbBuilder.addOffset(42, vectorOfNonOwningReferencesOffset);
1332    }
1333    fbBuilder.addUint8(43, _anyUniqueType?.value);
1334    if (anyUniqueOffset != null) {
1335      fbBuilder.addOffset(44, anyUniqueOffset);
1336    }
1337    fbBuilder.addUint8(45, _anyAmbiguousType?.value);
1338    if (anyAmbiguousOffset != null) {
1339      fbBuilder.addOffset(46, anyAmbiguousOffset);
1340    }
1341    if (vectorOfEnumsOffset != null) {
1342      fbBuilder.addOffset(47, vectorOfEnumsOffset);
1343    }
1344    fbBuilder.addInt8(48, _signedEnum?.value);
1345    return fbBuilder.endTable();
1346  }
1347
1348  /// Convenience method to serialize to byte list.
1349  @override
1350  Uint8List toBytes([String fileIdentifier]) {
1351    fb.Builder fbBuilder = new fb.Builder();
1352    int offset = finish(fbBuilder);
1353    return fbBuilder.finish(offset, fileIdentifier);
1354  }
1355}
1356class TypeAliases {
1357  TypeAliases._(this._bc, this._bcOffset);
1358  factory TypeAliases(List<int> bytes) {
1359    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
1360    return reader.read(rootRef, 0);
1361  }
1362
1363  static const fb.Reader<TypeAliases> reader = const _TypeAliasesReader();
1364
1365  final fb.BufferContext _bc;
1366  final int _bcOffset;
1367
1368  int get i8 => const fb.Int8Reader().vTableGet(_bc, _bcOffset, 4, 0);
1369  int get u8 => const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 6, 0);
1370  int get i16 => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 0);
1371  int get u16 => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 10, 0);
1372  int get i32 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 12, 0);
1373  int get u32 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 14, 0);
1374  int get i64 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 16, 0);
1375  int get u64 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 18, 0);
1376  double get f32 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 20, 0.0);
1377  double get f64 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 22, 0.0);
1378  List<int> get v8 => const fb.ListReader<int>(const fb.Int8Reader()).vTableGet(_bc, _bcOffset, 24, null);
1379  List<double> get vf64 => const fb.ListReader<double>(const fb.Float64Reader()).vTableGet(_bc, _bcOffset, 26, null);
1380
1381  @override
1382  String toString() {
1383    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}';
1384  }
1385}
1386
1387class _TypeAliasesReader extends fb.TableReader<TypeAliases> {
1388  const _TypeAliasesReader();
1389
1390  @override
1391  TypeAliases createObject(fb.BufferContext bc, int offset) =>
1392    new TypeAliases._(bc, offset);
1393}
1394
1395class TypeAliasesBuilder {
1396  TypeAliasesBuilder(this.fbBuilder) {
1397    assert(fbBuilder != null);
1398  }
1399
1400  final fb.Builder fbBuilder;
1401
1402  void begin() {
1403    fbBuilder.startTable();
1404  }
1405
1406  int addI8(int i8) {
1407    fbBuilder.addInt8(0, i8);
1408    return fbBuilder.offset;
1409  }
1410  int addU8(int u8) {
1411    fbBuilder.addUint8(1, u8);
1412    return fbBuilder.offset;
1413  }
1414  int addI16(int i16) {
1415    fbBuilder.addInt16(2, i16);
1416    return fbBuilder.offset;
1417  }
1418  int addU16(int u16) {
1419    fbBuilder.addUint16(3, u16);
1420    return fbBuilder.offset;
1421  }
1422  int addI32(int i32) {
1423    fbBuilder.addInt32(4, i32);
1424    return fbBuilder.offset;
1425  }
1426  int addU32(int u32) {
1427    fbBuilder.addUint32(5, u32);
1428    return fbBuilder.offset;
1429  }
1430  int addI64(int i64) {
1431    fbBuilder.addInt64(6, i64);
1432    return fbBuilder.offset;
1433  }
1434  int addU64(int u64) {
1435    fbBuilder.addUint64(7, u64);
1436    return fbBuilder.offset;
1437  }
1438  int addF32(double f32) {
1439    fbBuilder.addFloat32(8, f32);
1440    return fbBuilder.offset;
1441  }
1442  int addF64(double f64) {
1443    fbBuilder.addFloat64(9, f64);
1444    return fbBuilder.offset;
1445  }
1446  int addV8Offset(int offset) {
1447    fbBuilder.addOffset(10, offset);
1448    return fbBuilder.offset;
1449  }
1450  int addVf64Offset(int offset) {
1451    fbBuilder.addOffset(11, offset);
1452    return fbBuilder.offset;
1453  }
1454
1455  int finish() {
1456    return fbBuilder.endTable();
1457  }
1458}
1459
1460class TypeAliasesObjectBuilder extends fb.ObjectBuilder {
1461  final int _i8;
1462  final int _u8;
1463  final int _i16;
1464  final int _u16;
1465  final int _i32;
1466  final int _u32;
1467  final int _i64;
1468  final int _u64;
1469  final double _f32;
1470  final double _f64;
1471  final List<int> _v8;
1472  final List<double> _vf64;
1473
1474  TypeAliasesObjectBuilder({
1475    int i8,
1476    int u8,
1477    int i16,
1478    int u16,
1479    int i32,
1480    int u32,
1481    int i64,
1482    int u64,
1483    double f32,
1484    double f64,
1485    List<int> v8,
1486    List<double> vf64,
1487  })
1488      : _i8 = i8,
1489        _u8 = u8,
1490        _i16 = i16,
1491        _u16 = u16,
1492        _i32 = i32,
1493        _u32 = u32,
1494        _i64 = i64,
1495        _u64 = u64,
1496        _f32 = f32,
1497        _f64 = f64,
1498        _v8 = v8,
1499        _vf64 = vf64;
1500
1501  /// Finish building, and store into the [fbBuilder].
1502  @override
1503  int finish(
1504    fb.Builder fbBuilder) {
1505    assert(fbBuilder != null);
1506    final int v8Offset = _v8?.isNotEmpty == true
1507        ? fbBuilder.writeListInt8(_v8)
1508        : null;
1509    final int vf64Offset = _vf64?.isNotEmpty == true
1510        ? fbBuilder.writeListFloat64(_vf64)
1511        : null;
1512
1513    fbBuilder.startTable();
1514    fbBuilder.addInt8(0, _i8);
1515    fbBuilder.addUint8(1, _u8);
1516    fbBuilder.addInt16(2, _i16);
1517    fbBuilder.addUint16(3, _u16);
1518    fbBuilder.addInt32(4, _i32);
1519    fbBuilder.addUint32(5, _u32);
1520    fbBuilder.addInt64(6, _i64);
1521    fbBuilder.addUint64(7, _u64);
1522    fbBuilder.addFloat32(8, _f32);
1523    fbBuilder.addFloat64(9, _f64);
1524    if (v8Offset != null) {
1525      fbBuilder.addOffset(10, v8Offset);
1526    }
1527    if (vf64Offset != null) {
1528      fbBuilder.addOffset(11, vf64Offset);
1529    }
1530    return fbBuilder.endTable();
1531  }
1532
1533  /// Convenience method to serialize to byte list.
1534  @override
1535  Uint8List toBytes([String fileIdentifier]) {
1536    fb.Builder fbBuilder = new fb.Builder();
1537    int offset = finish(fbBuilder);
1538    return fbBuilder.finish(offset, fileIdentifier);
1539  }
1540}
1541