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