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