1 // automatically generated by the FlatBuffers compiler, do not modify 2 3 4 #ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ 5 #define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ 6 7 #include "flatbuffers/flatbuffers.h" 8 #include "flatbuffers/flexbuffers.h" 9 10 namespace MyGame { 11 12 struct InParentNamespace; 13 struct InParentNamespaceT; 14 15 namespace Example2 { 16 17 struct Monster; 18 struct MonsterT; 19 20 } // namespace Example2 21 22 namespace Example { 23 24 struct Test; 25 26 struct TestSimpleTableWithEnum; 27 struct TestSimpleTableWithEnumT; 28 29 struct Vec3; 30 31 struct Ability; 32 33 struct Stat; 34 struct StatT; 35 36 struct Referrable; 37 struct ReferrableT; 38 39 struct Monster; 40 struct MonsterT; 41 42 struct TypeAliases; 43 struct TypeAliasesT; 44 45 } // namespace Example 46 47 bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); 48 namespace Example2 { 49 50 bool operator==(const MonsterT &lhs, const MonsterT &rhs); 51 } // namespace Example2 52 53 namespace Example { 54 55 bool operator==(const Test &lhs, const Test &rhs); 56 bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); 57 bool operator==(const Vec3 &lhs, const Vec3 &rhs); 58 bool operator==(const Ability &lhs, const Ability &rhs); 59 bool operator==(const StatT &lhs, const StatT &rhs); 60 bool operator==(const ReferrableT &lhs, const ReferrableT &rhs); 61 bool operator==(const MonsterT &lhs, const MonsterT &rhs); 62 bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs); 63 64 } // namespace Example 65 66 inline const flatbuffers::TypeTable *InParentNamespaceTypeTable(); 67 68 namespace Example2 { 69 70 inline const flatbuffers::TypeTable *MonsterTypeTable(); 71 72 } // namespace Example2 73 74 namespace Example { 75 76 inline const flatbuffers::TypeTable *TestTypeTable(); 77 78 inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable(); 79 80 inline const flatbuffers::TypeTable *Vec3TypeTable(); 81 82 inline const flatbuffers::TypeTable *AbilityTypeTable(); 83 84 inline const flatbuffers::TypeTable *StatTypeTable(); 85 86 inline const flatbuffers::TypeTable *ReferrableTypeTable(); 87 88 inline const flatbuffers::TypeTable *MonsterTypeTable(); 89 90 inline const flatbuffers::TypeTable *TypeAliasesTypeTable(); 91 92 enum Color { 93 Color_Red = 1, 94 Color_Green = 2, 95 Color_Blue = 8, 96 Color_NONE = 0, 97 Color_ANY = 11 98 }; 99 100 inline const Color (&EnumValuesColor())[3] { 101 static const Color values[] = { 102 Color_Red, 103 Color_Green, 104 Color_Blue 105 }; 106 return values; 107 } 108 109 inline const char * const *EnumNamesColor() { 110 static const char * const names[] = { 111 "Red", 112 "Green", 113 "", 114 "", 115 "", 116 "", 117 "", 118 "Blue", 119 nullptr 120 }; 121 return names; 122 } 123 124 inline const char *EnumNameColor(Color e) { 125 if (e < Color_Red || e > Color_Blue) return ""; 126 const size_t index = static_cast<int>(e) - static_cast<int>(Color_Red); 127 return EnumNamesColor()[index]; 128 } 129 130 enum Any { 131 Any_NONE = 0, 132 Any_Monster = 1, 133 Any_TestSimpleTableWithEnum = 2, 134 Any_MyGame_Example2_Monster = 3, 135 Any_MIN = Any_NONE, 136 Any_MAX = Any_MyGame_Example2_Monster 137 }; 138 139 inline const Any (&EnumValuesAny())[4] { 140 static const Any values[] = { 141 Any_NONE, 142 Any_Monster, 143 Any_TestSimpleTableWithEnum, 144 Any_MyGame_Example2_Monster 145 }; 146 return values; 147 } 148 149 inline const char * const *EnumNamesAny() { 150 static const char * const names[] = { 151 "NONE", 152 "Monster", 153 "TestSimpleTableWithEnum", 154 "MyGame_Example2_Monster", 155 nullptr 156 }; 157 return names; 158 } 159 160 inline const char *EnumNameAny(Any e) { 161 if (e < Any_NONE || e > Any_MyGame_Example2_Monster) return ""; 162 const size_t index = static_cast<int>(e); 163 return EnumNamesAny()[index]; 164 } 165 166 template<typename T> struct AnyTraits { 167 static const Any enum_value = Any_NONE; 168 }; 169 170 template<> struct AnyTraits<Monster> { 171 static const Any enum_value = Any_Monster; 172 }; 173 174 template<> struct AnyTraits<TestSimpleTableWithEnum> { 175 static const Any enum_value = Any_TestSimpleTableWithEnum; 176 }; 177 178 template<> struct AnyTraits<MyGame::Example2::Monster> { 179 static const Any enum_value = Any_MyGame_Example2_Monster; 180 }; 181 182 struct AnyUnion { 183 Any type; 184 void *value; 185 186 AnyUnion() : type(Any_NONE), value(nullptr) {} 187 AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT : 188 type(Any_NONE), value(nullptr) 189 { std::swap(type, u.type); std::swap(value, u.value); } 190 AnyUnion(const AnyUnion &) FLATBUFFERS_NOEXCEPT; 191 AnyUnion &operator=(const AnyUnion &u) FLATBUFFERS_NOEXCEPT 192 { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 193 AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT 194 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 195 ~AnyUnion() { Reset(); } 196 197 void Reset(); 198 199 #ifndef FLATBUFFERS_CPP98_STL 200 template <typename T> 201 void Set(T&& val) { 202 Reset(); 203 type = AnyTraits<typename T::TableType>::enum_value; 204 if (type != Any_NONE) { 205 value = new T(std::forward<T>(val)); 206 } 207 } 208 #endif // FLATBUFFERS_CPP98_STL 209 210 static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); 211 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 212 213 MonsterT *AsMonster() { 214 return type == Any_Monster ? 215 reinterpret_cast<MonsterT *>(value) : nullptr; 216 } 217 const MonsterT *AsMonster() const { 218 return type == Any_Monster ? 219 reinterpret_cast<const MonsterT *>(value) : nullptr; 220 } 221 TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { 222 return type == Any_TestSimpleTableWithEnum ? 223 reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr; 224 } 225 const TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const { 226 return type == Any_TestSimpleTableWithEnum ? 227 reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr; 228 } 229 MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { 230 return type == Any_MyGame_Example2_Monster ? 231 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr; 232 } 233 const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const { 234 return type == Any_MyGame_Example2_Monster ? 235 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr; 236 } 237 }; 238 239 240 inline bool operator==(const AnyUnion &lhs, const AnyUnion &rhs) { 241 if (lhs.type != rhs.type) return false; 242 switch (lhs.type) { 243 case Any_NONE: { 244 return true; 245 } 246 case Any_Monster: { 247 return *(reinterpret_cast<const MonsterT *>(lhs.value)) == 248 *(reinterpret_cast<const MonsterT *>(rhs.value)); 249 } 250 case Any_TestSimpleTableWithEnum: { 251 return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) == 252 *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value)); 253 } 254 case Any_MyGame_Example2_Monster: { 255 return *(reinterpret_cast<const MyGame::Example2::MonsterT *>(lhs.value)) == 256 *(reinterpret_cast<const MyGame::Example2::MonsterT *>(rhs.value)); 257 } 258 default: { 259 return false; 260 } 261 } 262 } 263 bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); 264 bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 265 266 enum AnyUniqueAliases { 267 AnyUniqueAliases_NONE = 0, 268 AnyUniqueAliases_M = 1, 269 AnyUniqueAliases_T = 2, 270 AnyUniqueAliases_M2 = 3, 271 AnyUniqueAliases_MIN = AnyUniqueAliases_NONE, 272 AnyUniqueAliases_MAX = AnyUniqueAliases_M2 273 }; 274 275 inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] { 276 static const AnyUniqueAliases values[] = { 277 AnyUniqueAliases_NONE, 278 AnyUniqueAliases_M, 279 AnyUniqueAliases_T, 280 AnyUniqueAliases_M2 281 }; 282 return values; 283 } 284 285 inline const char * const *EnumNamesAnyUniqueAliases() { 286 static const char * const names[] = { 287 "NONE", 288 "M", 289 "T", 290 "M2", 291 nullptr 292 }; 293 return names; 294 } 295 296 inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) { 297 if (e < AnyUniqueAliases_NONE || e > AnyUniqueAliases_M2) return ""; 298 const size_t index = static_cast<int>(e); 299 return EnumNamesAnyUniqueAliases()[index]; 300 } 301 302 template<typename T> struct AnyUniqueAliasesTraits { 303 static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; 304 }; 305 306 template<> struct AnyUniqueAliasesTraits<Monster> { 307 static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; 308 }; 309 310 template<> struct AnyUniqueAliasesTraits<TestSimpleTableWithEnum> { 311 static const AnyUniqueAliases enum_value = AnyUniqueAliases_T; 312 }; 313 314 template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> { 315 static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; 316 }; 317 318 struct AnyUniqueAliasesUnion { 319 AnyUniqueAliases type; 320 void *value; 321 322 AnyUniqueAliasesUnion() : type(AnyUniqueAliases_NONE), value(nullptr) {} 323 AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : 324 type(AnyUniqueAliases_NONE), value(nullptr) 325 { std::swap(type, u.type); std::swap(value, u.value); } 326 AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &) FLATBUFFERS_NOEXCEPT; 327 AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u) FLATBUFFERS_NOEXCEPT 328 { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 329 AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT 330 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 331 ~AnyUniqueAliasesUnion() { Reset(); } 332 333 void Reset(); 334 335 #ifndef FLATBUFFERS_CPP98_STL 336 template <typename T> 337 void Set(T&& val) { 338 Reset(); 339 type = AnyUniqueAliasesTraits<typename T::TableType>::enum_value; 340 if (type != AnyUniqueAliases_NONE) { 341 value = new T(std::forward<T>(val)); 342 } 343 } 344 #endif // FLATBUFFERS_CPP98_STL 345 346 static void *UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver); 347 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 348 349 MonsterT *AsM() { 350 return type == AnyUniqueAliases_M ? 351 reinterpret_cast<MonsterT *>(value) : nullptr; 352 } 353 const MonsterT *AsM() const { 354 return type == AnyUniqueAliases_M ? 355 reinterpret_cast<const MonsterT *>(value) : nullptr; 356 } 357 TestSimpleTableWithEnumT *AsT() { 358 return type == AnyUniqueAliases_T ? 359 reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr; 360 } 361 const TestSimpleTableWithEnumT *AsT() const { 362 return type == AnyUniqueAliases_T ? 363 reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr; 364 } 365 MyGame::Example2::MonsterT *AsM2() { 366 return type == AnyUniqueAliases_M2 ? 367 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr; 368 } 369 const MyGame::Example2::MonsterT *AsM2() const { 370 return type == AnyUniqueAliases_M2 ? 371 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr; 372 } 373 }; 374 375 376 inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { 377 if (lhs.type != rhs.type) return false; 378 switch (lhs.type) { 379 case AnyUniqueAliases_NONE: { 380 return true; 381 } 382 case AnyUniqueAliases_M: { 383 return *(reinterpret_cast<const MonsterT *>(lhs.value)) == 384 *(reinterpret_cast<const MonsterT *>(rhs.value)); 385 } 386 case AnyUniqueAliases_T: { 387 return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) == 388 *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value)); 389 } 390 case AnyUniqueAliases_M2: { 391 return *(reinterpret_cast<const MyGame::Example2::MonsterT *>(lhs.value)) == 392 *(reinterpret_cast<const MyGame::Example2::MonsterT *>(rhs.value)); 393 } 394 default: { 395 return false; 396 } 397 } 398 } 399 bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type); 400 bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 401 402 enum AnyAmbiguousAliases { 403 AnyAmbiguousAliases_NONE = 0, 404 AnyAmbiguousAliases_M1 = 1, 405 AnyAmbiguousAliases_M2 = 2, 406 AnyAmbiguousAliases_M3 = 3, 407 AnyAmbiguousAliases_MIN = AnyAmbiguousAliases_NONE, 408 AnyAmbiguousAliases_MAX = AnyAmbiguousAliases_M3 409 }; 410 411 inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] { 412 static const AnyAmbiguousAliases values[] = { 413 AnyAmbiguousAliases_NONE, 414 AnyAmbiguousAliases_M1, 415 AnyAmbiguousAliases_M2, 416 AnyAmbiguousAliases_M3 417 }; 418 return values; 419 } 420 421 inline const char * const *EnumNamesAnyAmbiguousAliases() { 422 static const char * const names[] = { 423 "NONE", 424 "M1", 425 "M2", 426 "M3", 427 nullptr 428 }; 429 return names; 430 } 431 432 inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) { 433 if (e < AnyAmbiguousAliases_NONE || e > AnyAmbiguousAliases_M3) return ""; 434 const size_t index = static_cast<int>(e); 435 return EnumNamesAnyAmbiguousAliases()[index]; 436 } 437 438 struct AnyAmbiguousAliasesUnion { 439 AnyAmbiguousAliases type; 440 void *value; 441 442 AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases_NONE), value(nullptr) {} 443 AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : 444 type(AnyAmbiguousAliases_NONE), value(nullptr) 445 { std::swap(type, u.type); std::swap(value, u.value); } 446 AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &) FLATBUFFERS_NOEXCEPT; 447 AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u) FLATBUFFERS_NOEXCEPT 448 { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 449 AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT 450 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 451 ~AnyAmbiguousAliasesUnion() { Reset(); } 452 453 void Reset(); 454 455 static void *UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver); 456 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 457 458 MonsterT *AsM1() { 459 return type == AnyAmbiguousAliases_M1 ? 460 reinterpret_cast<MonsterT *>(value) : nullptr; 461 } 462 const MonsterT *AsM1() const { 463 return type == AnyAmbiguousAliases_M1 ? 464 reinterpret_cast<const MonsterT *>(value) : nullptr; 465 } 466 MonsterT *AsM2() { 467 return type == AnyAmbiguousAliases_M2 ? 468 reinterpret_cast<MonsterT *>(value) : nullptr; 469 } 470 const MonsterT *AsM2() const { 471 return type == AnyAmbiguousAliases_M2 ? 472 reinterpret_cast<const MonsterT *>(value) : nullptr; 473 } 474 MonsterT *AsM3() { 475 return type == AnyAmbiguousAliases_M3 ? 476 reinterpret_cast<MonsterT *>(value) : nullptr; 477 } 478 const MonsterT *AsM3() const { 479 return type == AnyAmbiguousAliases_M3 ? 480 reinterpret_cast<const MonsterT *>(value) : nullptr; 481 } 482 }; 483 484 485 inline bool operator==(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { 486 if (lhs.type != rhs.type) return false; 487 switch (lhs.type) { 488 case AnyAmbiguousAliases_NONE: { 489 return true; 490 } 491 case AnyAmbiguousAliases_M1: { 492 return *(reinterpret_cast<const MonsterT *>(lhs.value)) == 493 *(reinterpret_cast<const MonsterT *>(rhs.value)); 494 } 495 case AnyAmbiguousAliases_M2: { 496 return *(reinterpret_cast<const MonsterT *>(lhs.value)) == 497 *(reinterpret_cast<const MonsterT *>(rhs.value)); 498 } 499 case AnyAmbiguousAliases_M3: { 500 return *(reinterpret_cast<const MonsterT *>(lhs.value)) == 501 *(reinterpret_cast<const MonsterT *>(rhs.value)); 502 } 503 default: { 504 return false; 505 } 506 } 507 } 508 bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type); 509 bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 510 511 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { 512 private: 513 int16_t a_; 514 int8_t b_; 515 int8_t padding0__; 516 517 public: 518 Test() { 519 memset(static_cast<void *>(this), 0, sizeof(Test)); 520 } 521 Test(int16_t _a, int8_t _b) 522 : a_(flatbuffers::EndianScalar(_a)), 523 b_(flatbuffers::EndianScalar(_b)), 524 padding0__(0) { 525 (void)padding0__; 526 } 527 int16_t a() const { 528 return flatbuffers::EndianScalar(a_); 529 } 530 void mutate_a(int16_t _a) { 531 flatbuffers::WriteScalar(&a_, _a); 532 } 533 int8_t b() const { 534 return flatbuffers::EndianScalar(b_); 535 } 536 void mutate_b(int8_t _b) { 537 flatbuffers::WriteScalar(&b_, _b); 538 } 539 }; 540 FLATBUFFERS_STRUCT_END(Test, 4); 541 542 inline bool operator==(const Test &lhs, const Test &rhs) { 543 return 544 (lhs.a() == rhs.a()) && 545 (lhs.b() == rhs.b()); 546 } 547 548 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS { 549 private: 550 float x_; 551 float y_; 552 float z_; 553 int32_t padding0__; 554 double test1_; 555 int8_t test2_; 556 int8_t padding1__; 557 Test test3_; 558 int16_t padding2__; 559 560 public: 561 Vec3() { 562 memset(static_cast<void *>(this), 0, sizeof(Vec3)); 563 } 564 Vec3(float _x, float _y, float _z, double _test1, Color _test2, const Test &_test3) 565 : x_(flatbuffers::EndianScalar(_x)), 566 y_(flatbuffers::EndianScalar(_y)), 567 z_(flatbuffers::EndianScalar(_z)), 568 padding0__(0), 569 test1_(flatbuffers::EndianScalar(_test1)), 570 test2_(flatbuffers::EndianScalar(static_cast<int8_t>(_test2))), 571 padding1__(0), 572 test3_(_test3), 573 padding2__(0) { 574 (void)padding0__; 575 (void)padding1__; 576 (void)padding2__; 577 } 578 float x() const { 579 return flatbuffers::EndianScalar(x_); 580 } 581 void mutate_x(float _x) { 582 flatbuffers::WriteScalar(&x_, _x); 583 } 584 float y() const { 585 return flatbuffers::EndianScalar(y_); 586 } 587 void mutate_y(float _y) { 588 flatbuffers::WriteScalar(&y_, _y); 589 } 590 float z() const { 591 return flatbuffers::EndianScalar(z_); 592 } 593 void mutate_z(float _z) { 594 flatbuffers::WriteScalar(&z_, _z); 595 } 596 double test1() const { 597 return flatbuffers::EndianScalar(test1_); 598 } 599 void mutate_test1(double _test1) { 600 flatbuffers::WriteScalar(&test1_, _test1); 601 } 602 Color test2() const { 603 return static_cast<Color>(flatbuffers::EndianScalar(test2_)); 604 } 605 void mutate_test2(Color _test2) { 606 flatbuffers::WriteScalar(&test2_, static_cast<int8_t>(_test2)); 607 } 608 const Test &test3() const { 609 return test3_; 610 } 611 Test &mutable_test3() { 612 return test3_; 613 } 614 }; 615 FLATBUFFERS_STRUCT_END(Vec3, 32); 616 617 inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) { 618 return 619 (lhs.x() == rhs.x()) && 620 (lhs.y() == rhs.y()) && 621 (lhs.z() == rhs.z()) && 622 (lhs.test1() == rhs.test1()) && 623 (lhs.test2() == rhs.test2()) && 624 (lhs.test3() == rhs.test3()); 625 } 626 627 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS { 628 private: 629 uint32_t id_; 630 uint32_t distance_; 631 632 public: 633 Ability() { 634 memset(static_cast<void *>(this), 0, sizeof(Ability)); 635 } 636 Ability(uint32_t _id, uint32_t _distance) 637 : id_(flatbuffers::EndianScalar(_id)), 638 distance_(flatbuffers::EndianScalar(_distance)) { 639 } 640 uint32_t id() const { 641 return flatbuffers::EndianScalar(id_); 642 } 643 void mutate_id(uint32_t _id) { 644 flatbuffers::WriteScalar(&id_, _id); 645 } 646 bool KeyCompareLessThan(const Ability *o) const { 647 return id() < o->id(); 648 } 649 int KeyCompareWithValue(uint32_t val) const { 650 return static_cast<int>(id() > val) - static_cast<int>(id() < val); 651 } 652 uint32_t distance() const { 653 return flatbuffers::EndianScalar(distance_); 654 } 655 void mutate_distance(uint32_t _distance) { 656 flatbuffers::WriteScalar(&distance_, _distance); 657 } 658 }; 659 FLATBUFFERS_STRUCT_END(Ability, 8); 660 661 inline bool operator==(const Ability &lhs, const Ability &rhs) { 662 return 663 (lhs.id() == rhs.id()) && 664 (lhs.distance() == rhs.distance()); 665 } 666 667 } // namespace Example 668 669 struct InParentNamespaceT : public flatbuffers::NativeTable { 670 typedef InParentNamespace TableType; 671 InParentNamespaceT() { 672 } 673 }; 674 675 inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) { 676 return true; 677 } 678 679 struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 680 typedef InParentNamespaceT NativeTableType; 681 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 682 return InParentNamespaceTypeTable(); 683 } 684 bool Verify(flatbuffers::Verifier &verifier) const { 685 return VerifyTableStart(verifier) && 686 verifier.EndTable(); 687 } 688 InParentNamespaceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 689 void UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 690 static flatbuffers::Offset<InParentNamespace> Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 691 }; 692 693 struct InParentNamespaceBuilder { 694 flatbuffers::FlatBufferBuilder &fbb_; 695 flatbuffers::uoffset_t start_; 696 explicit InParentNamespaceBuilder(flatbuffers::FlatBufferBuilder &_fbb) 697 : fbb_(_fbb) { 698 start_ = fbb_.StartTable(); 699 } 700 InParentNamespaceBuilder &operator=(const InParentNamespaceBuilder &); 701 flatbuffers::Offset<InParentNamespace> Finish() { 702 const auto end = fbb_.EndTable(start_); 703 auto o = flatbuffers::Offset<InParentNamespace>(end); 704 return o; 705 } 706 }; 707 708 inline flatbuffers::Offset<InParentNamespace> CreateInParentNamespace( 709 flatbuffers::FlatBufferBuilder &_fbb) { 710 InParentNamespaceBuilder builder_(_fbb); 711 return builder_.Finish(); 712 } 713 714 flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 715 716 namespace Example2 { 717 718 struct MonsterT : public flatbuffers::NativeTable { 719 typedef Monster TableType; 720 MonsterT() { 721 } 722 }; 723 724 inline bool operator==(const MonsterT &, const MonsterT &) { 725 return true; 726 } 727 728 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 729 typedef MonsterT NativeTableType; 730 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 731 return MonsterTypeTable(); 732 } 733 bool Verify(flatbuffers::Verifier &verifier) const { 734 return VerifyTableStart(verifier) && 735 verifier.EndTable(); 736 } 737 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 738 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 739 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 740 }; 741 742 struct MonsterBuilder { 743 flatbuffers::FlatBufferBuilder &fbb_; 744 flatbuffers::uoffset_t start_; 745 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) 746 : fbb_(_fbb) { 747 start_ = fbb_.StartTable(); 748 } 749 MonsterBuilder &operator=(const MonsterBuilder &); 750 flatbuffers::Offset<Monster> Finish() { 751 const auto end = fbb_.EndTable(start_); 752 auto o = flatbuffers::Offset<Monster>(end); 753 return o; 754 } 755 }; 756 757 inline flatbuffers::Offset<Monster> CreateMonster( 758 flatbuffers::FlatBufferBuilder &_fbb) { 759 MonsterBuilder builder_(_fbb); 760 return builder_.Finish(); 761 } 762 763 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 764 765 } // namespace Example2 766 767 namespace Example { 768 769 struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { 770 typedef TestSimpleTableWithEnum TableType; 771 Color color; 772 TestSimpleTableWithEnumT() 773 : color(Color_Green) { 774 } 775 }; 776 777 inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { 778 return 779 (lhs.color == rhs.color); 780 } 781 782 struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 783 typedef TestSimpleTableWithEnumT NativeTableType; 784 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 785 return TestSimpleTableWithEnumTypeTable(); 786 } 787 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 788 VT_COLOR = 4 789 }; 790 Color color() const { 791 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 2)); 792 } 793 bool mutate_color(Color _color) { 794 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2); 795 } 796 bool Verify(flatbuffers::Verifier &verifier) const { 797 return VerifyTableStart(verifier) && 798 VerifyField<int8_t>(verifier, VT_COLOR) && 799 verifier.EndTable(); 800 } 801 TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 802 void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 803 static flatbuffers::Offset<TestSimpleTableWithEnum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 804 }; 805 806 struct TestSimpleTableWithEnumBuilder { 807 flatbuffers::FlatBufferBuilder &fbb_; 808 flatbuffers::uoffset_t start_; 809 void add_color(Color color) { 810 fbb_.AddElement<int8_t>(TestSimpleTableWithEnum::VT_COLOR, static_cast<int8_t>(color), 2); 811 } 812 explicit TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) 813 : fbb_(_fbb) { 814 start_ = fbb_.StartTable(); 815 } 816 TestSimpleTableWithEnumBuilder &operator=(const TestSimpleTableWithEnumBuilder &); 817 flatbuffers::Offset<TestSimpleTableWithEnum> Finish() { 818 const auto end = fbb_.EndTable(start_); 819 auto o = flatbuffers::Offset<TestSimpleTableWithEnum>(end); 820 return o; 821 } 822 }; 823 824 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum( 825 flatbuffers::FlatBufferBuilder &_fbb, 826 Color color = Color_Green) { 827 TestSimpleTableWithEnumBuilder builder_(_fbb); 828 builder_.add_color(color); 829 return builder_.Finish(); 830 } 831 832 flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 833 834 struct StatT : public flatbuffers::NativeTable { 835 typedef Stat TableType; 836 std::string id; 837 int64_t val; 838 uint16_t count; 839 StatT() 840 : val(0), 841 count(0) { 842 } 843 }; 844 845 inline bool operator==(const StatT &lhs, const StatT &rhs) { 846 return 847 (lhs.id == rhs.id) && 848 (lhs.val == rhs.val) && 849 (lhs.count == rhs.count); 850 } 851 852 struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 853 typedef StatT NativeTableType; 854 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 855 return StatTypeTable(); 856 } 857 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 858 VT_ID = 4, 859 VT_VAL = 6, 860 VT_COUNT = 8 861 }; 862 const flatbuffers::String *id() const { 863 return GetPointer<const flatbuffers::String *>(VT_ID); 864 } 865 flatbuffers::String *mutable_id() { 866 return GetPointer<flatbuffers::String *>(VT_ID); 867 } 868 int64_t val() const { 869 return GetField<int64_t>(VT_VAL, 0); 870 } 871 bool mutate_val(int64_t _val) { 872 return SetField<int64_t>(VT_VAL, _val, 0); 873 } 874 uint16_t count() const { 875 return GetField<uint16_t>(VT_COUNT, 0); 876 } 877 bool mutate_count(uint16_t _count) { 878 return SetField<uint16_t>(VT_COUNT, _count, 0); 879 } 880 bool Verify(flatbuffers::Verifier &verifier) const { 881 return VerifyTableStart(verifier) && 882 VerifyOffset(verifier, VT_ID) && 883 verifier.VerifyString(id()) && 884 VerifyField<int64_t>(verifier, VT_VAL) && 885 VerifyField<uint16_t>(verifier, VT_COUNT) && 886 verifier.EndTable(); 887 } 888 StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 889 void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 890 static flatbuffers::Offset<Stat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 891 }; 892 893 struct StatBuilder { 894 flatbuffers::FlatBufferBuilder &fbb_; 895 flatbuffers::uoffset_t start_; 896 void add_id(flatbuffers::Offset<flatbuffers::String> id) { 897 fbb_.AddOffset(Stat::VT_ID, id); 898 } 899 void add_val(int64_t val) { 900 fbb_.AddElement<int64_t>(Stat::VT_VAL, val, 0); 901 } 902 void add_count(uint16_t count) { 903 fbb_.AddElement<uint16_t>(Stat::VT_COUNT, count, 0); 904 } 905 explicit StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) 906 : fbb_(_fbb) { 907 start_ = fbb_.StartTable(); 908 } 909 StatBuilder &operator=(const StatBuilder &); 910 flatbuffers::Offset<Stat> Finish() { 911 const auto end = fbb_.EndTable(start_); 912 auto o = flatbuffers::Offset<Stat>(end); 913 return o; 914 } 915 }; 916 917 inline flatbuffers::Offset<Stat> CreateStat( 918 flatbuffers::FlatBufferBuilder &_fbb, 919 flatbuffers::Offset<flatbuffers::String> id = 0, 920 int64_t val = 0, 921 uint16_t count = 0) { 922 StatBuilder builder_(_fbb); 923 builder_.add_val(val); 924 builder_.add_id(id); 925 builder_.add_count(count); 926 return builder_.Finish(); 927 } 928 929 inline flatbuffers::Offset<Stat> CreateStatDirect( 930 flatbuffers::FlatBufferBuilder &_fbb, 931 const char *id = nullptr, 932 int64_t val = 0, 933 uint16_t count = 0) { 934 auto id__ = id ? _fbb.CreateString(id) : 0; 935 return MyGame::Example::CreateStat( 936 _fbb, 937 id__, 938 val, 939 count); 940 } 941 942 flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 943 944 struct ReferrableT : public flatbuffers::NativeTable { 945 typedef Referrable TableType; 946 uint64_t id; 947 ReferrableT() 948 : id(0) { 949 } 950 }; 951 952 inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) { 953 return 954 (lhs.id == rhs.id); 955 } 956 957 struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 958 typedef ReferrableT NativeTableType; 959 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 960 return ReferrableTypeTable(); 961 } 962 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 963 VT_ID = 4 964 }; 965 uint64_t id() const { 966 return GetField<uint64_t>(VT_ID, 0); 967 } 968 bool mutate_id(uint64_t _id) { 969 return SetField<uint64_t>(VT_ID, _id, 0); 970 } 971 bool KeyCompareLessThan(const Referrable *o) const { 972 return id() < o->id(); 973 } 974 int KeyCompareWithValue(uint64_t val) const { 975 return static_cast<int>(id() > val) - static_cast<int>(id() < val); 976 } 977 bool Verify(flatbuffers::Verifier &verifier) const { 978 return VerifyTableStart(verifier) && 979 VerifyField<uint64_t>(verifier, VT_ID) && 980 verifier.EndTable(); 981 } 982 ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 983 void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 984 static flatbuffers::Offset<Referrable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 985 }; 986 987 struct ReferrableBuilder { 988 flatbuffers::FlatBufferBuilder &fbb_; 989 flatbuffers::uoffset_t start_; 990 void add_id(uint64_t id) { 991 fbb_.AddElement<uint64_t>(Referrable::VT_ID, id, 0); 992 } 993 explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb) 994 : fbb_(_fbb) { 995 start_ = fbb_.StartTable(); 996 } 997 ReferrableBuilder &operator=(const ReferrableBuilder &); 998 flatbuffers::Offset<Referrable> Finish() { 999 const auto end = fbb_.EndTable(start_); 1000 auto o = flatbuffers::Offset<Referrable>(end); 1001 return o; 1002 } 1003 }; 1004 1005 inline flatbuffers::Offset<Referrable> CreateReferrable( 1006 flatbuffers::FlatBufferBuilder &_fbb, 1007 uint64_t id = 0) { 1008 ReferrableBuilder builder_(_fbb); 1009 builder_.add_id(id); 1010 return builder_.Finish(); 1011 } 1012 1013 flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1014 1015 struct MonsterT : public flatbuffers::NativeTable { 1016 typedef Monster TableType; 1017 flatbuffers::unique_ptr<Vec3> pos; 1018 int16_t mana; 1019 int16_t hp; 1020 std::string name; 1021 std::vector<uint8_t> inventory; 1022 Color color; 1023 AnyUnion test; 1024 std::vector<Test> test4; 1025 std::vector<std::string> testarrayofstring; 1026 std::vector<flatbuffers::unique_ptr<MonsterT>> testarrayoftables; 1027 flatbuffers::unique_ptr<MonsterT> enemy; 1028 std::vector<uint8_t> testnestedflatbuffer; 1029 flatbuffers::unique_ptr<StatT> testempty; 1030 bool testbool; 1031 int32_t testhashs32_fnv1; 1032 uint32_t testhashu32_fnv1; 1033 int64_t testhashs64_fnv1; 1034 uint64_t testhashu64_fnv1; 1035 int32_t testhashs32_fnv1a; 1036 Stat *testhashu32_fnv1a; 1037 int64_t testhashs64_fnv1a; 1038 uint64_t testhashu64_fnv1a; 1039 std::vector<bool> testarrayofbools; 1040 float testf; 1041 float testf2; 1042 float testf3; 1043 std::vector<std::string> testarrayofstring2; 1044 std::vector<Ability> testarrayofsortedstruct; 1045 std::vector<uint8_t> flex; 1046 std::vector<Test> test5; 1047 std::vector<int64_t> vector_of_longs; 1048 std::vector<double> vector_of_doubles; 1049 flatbuffers::unique_ptr<MyGame::InParentNamespaceT> parent_namespace_test; 1050 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_referrables; 1051 ReferrableT *single_weak_reference; 1052 std::vector<ReferrableT *> vector_of_weak_references; 1053 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_strong_referrables; 1054 ReferrableT *co_owning_reference; 1055 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_co_owning_references; 1056 ReferrableT *non_owning_reference; 1057 std::vector<ReferrableT *> vector_of_non_owning_references; 1058 AnyUniqueAliasesUnion any_unique; 1059 AnyAmbiguousAliasesUnion any_ambiguous; 1060 std::vector<Color> vector_of_enums; 1061 MonsterT() 1062 : mana(150), 1063 hp(100), 1064 color(Color_Blue), 1065 testbool(false), 1066 testhashs32_fnv1(0), 1067 testhashu32_fnv1(0), 1068 testhashs64_fnv1(0), 1069 testhashu64_fnv1(0), 1070 testhashs32_fnv1a(0), 1071 testhashu32_fnv1a(nullptr), 1072 testhashs64_fnv1a(0), 1073 testhashu64_fnv1a(0), 1074 testf(3.14159f), 1075 testf2(3.0f), 1076 testf3(0.0f), 1077 single_weak_reference(nullptr), 1078 co_owning_reference(nullptr), 1079 non_owning_reference(nullptr) { 1080 } 1081 }; 1082 1083 inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { 1084 return 1085 (lhs.pos == rhs.pos) && 1086 (lhs.mana == rhs.mana) && 1087 (lhs.hp == rhs.hp) && 1088 (lhs.name == rhs.name) && 1089 (lhs.inventory == rhs.inventory) && 1090 (lhs.color == rhs.color) && 1091 (lhs.test == rhs.test) && 1092 (lhs.test4 == rhs.test4) && 1093 (lhs.testarrayofstring == rhs.testarrayofstring) && 1094 (lhs.testarrayoftables == rhs.testarrayoftables) && 1095 (lhs.enemy == rhs.enemy) && 1096 (lhs.testnestedflatbuffer == rhs.testnestedflatbuffer) && 1097 (lhs.testempty == rhs.testempty) && 1098 (lhs.testbool == rhs.testbool) && 1099 (lhs.testhashs32_fnv1 == rhs.testhashs32_fnv1) && 1100 (lhs.testhashu32_fnv1 == rhs.testhashu32_fnv1) && 1101 (lhs.testhashs64_fnv1 == rhs.testhashs64_fnv1) && 1102 (lhs.testhashu64_fnv1 == rhs.testhashu64_fnv1) && 1103 (lhs.testhashs32_fnv1a == rhs.testhashs32_fnv1a) && 1104 (lhs.testhashu32_fnv1a == rhs.testhashu32_fnv1a) && 1105 (lhs.testhashs64_fnv1a == rhs.testhashs64_fnv1a) && 1106 (lhs.testhashu64_fnv1a == rhs.testhashu64_fnv1a) && 1107 (lhs.testarrayofbools == rhs.testarrayofbools) && 1108 (lhs.testf == rhs.testf) && 1109 (lhs.testf2 == rhs.testf2) && 1110 (lhs.testf3 == rhs.testf3) && 1111 (lhs.testarrayofstring2 == rhs.testarrayofstring2) && 1112 (lhs.testarrayofsortedstruct == rhs.testarrayofsortedstruct) && 1113 (lhs.flex == rhs.flex) && 1114 (lhs.test5 == rhs.test5) && 1115 (lhs.vector_of_longs == rhs.vector_of_longs) && 1116 (lhs.vector_of_doubles == rhs.vector_of_doubles) && 1117 (lhs.parent_namespace_test == rhs.parent_namespace_test) && 1118 (lhs.vector_of_referrables == rhs.vector_of_referrables) && 1119 (lhs.single_weak_reference == rhs.single_weak_reference) && 1120 (lhs.vector_of_weak_references == rhs.vector_of_weak_references) && 1121 (lhs.vector_of_strong_referrables == rhs.vector_of_strong_referrables) && 1122 (lhs.co_owning_reference == rhs.co_owning_reference) && 1123 (lhs.vector_of_co_owning_references == rhs.vector_of_co_owning_references) && 1124 (lhs.non_owning_reference == rhs.non_owning_reference) && 1125 (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) && 1126 (lhs.any_unique == rhs.any_unique) && 1127 (lhs.any_ambiguous == rhs.any_ambiguous) && 1128 (lhs.vector_of_enums == rhs.vector_of_enums); 1129 } 1130 1131 /// an example documentation comment: monster object 1132 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1133 typedef MonsterT NativeTableType; 1134 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 1135 return MonsterTypeTable(); 1136 } 1137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1138 VT_POS = 4, 1139 VT_MANA = 6, 1140 VT_HP = 8, 1141 VT_NAME = 10, 1142 VT_INVENTORY = 14, 1143 VT_COLOR = 16, 1144 VT_TEST_TYPE = 18, 1145 VT_TEST = 20, 1146 VT_TEST4 = 22, 1147 VT_TESTARRAYOFSTRING = 24, 1148 VT_TESTARRAYOFTABLES = 26, 1149 VT_ENEMY = 28, 1150 VT_TESTNESTEDFLATBUFFER = 30, 1151 VT_TESTEMPTY = 32, 1152 VT_TESTBOOL = 34, 1153 VT_TESTHASHS32_FNV1 = 36, 1154 VT_TESTHASHU32_FNV1 = 38, 1155 VT_TESTHASHS64_FNV1 = 40, 1156 VT_TESTHASHU64_FNV1 = 42, 1157 VT_TESTHASHS32_FNV1A = 44, 1158 VT_TESTHASHU32_FNV1A = 46, 1159 VT_TESTHASHS64_FNV1A = 48, 1160 VT_TESTHASHU64_FNV1A = 50, 1161 VT_TESTARRAYOFBOOLS = 52, 1162 VT_TESTF = 54, 1163 VT_TESTF2 = 56, 1164 VT_TESTF3 = 58, 1165 VT_TESTARRAYOFSTRING2 = 60, 1166 VT_TESTARRAYOFSORTEDSTRUCT = 62, 1167 VT_FLEX = 64, 1168 VT_TEST5 = 66, 1169 VT_VECTOR_OF_LONGS = 68, 1170 VT_VECTOR_OF_DOUBLES = 70, 1171 VT_PARENT_NAMESPACE_TEST = 72, 1172 VT_VECTOR_OF_REFERRABLES = 74, 1173 VT_SINGLE_WEAK_REFERENCE = 76, 1174 VT_VECTOR_OF_WEAK_REFERENCES = 78, 1175 VT_VECTOR_OF_STRONG_REFERRABLES = 80, 1176 VT_CO_OWNING_REFERENCE = 82, 1177 VT_VECTOR_OF_CO_OWNING_REFERENCES = 84, 1178 VT_NON_OWNING_REFERENCE = 86, 1179 VT_VECTOR_OF_NON_OWNING_REFERENCES = 88, 1180 VT_ANY_UNIQUE_TYPE = 90, 1181 VT_ANY_UNIQUE = 92, 1182 VT_ANY_AMBIGUOUS_TYPE = 94, 1183 VT_ANY_AMBIGUOUS = 96, 1184 VT_VECTOR_OF_ENUMS = 98 1185 }; 1186 const Vec3 *pos() const { 1187 return GetStruct<const Vec3 *>(VT_POS); 1188 } 1189 Vec3 *mutable_pos() { 1190 return GetStruct<Vec3 *>(VT_POS); 1191 } 1192 int16_t mana() const { 1193 return GetField<int16_t>(VT_MANA, 150); 1194 } 1195 bool mutate_mana(int16_t _mana) { 1196 return SetField<int16_t>(VT_MANA, _mana, 150); 1197 } 1198 int16_t hp() const { 1199 return GetField<int16_t>(VT_HP, 100); 1200 } 1201 bool mutate_hp(int16_t _hp) { 1202 return SetField<int16_t>(VT_HP, _hp, 100); 1203 } 1204 const flatbuffers::String *name() const { 1205 return GetPointer<const flatbuffers::String *>(VT_NAME); 1206 } 1207 flatbuffers::String *mutable_name() { 1208 return GetPointer<flatbuffers::String *>(VT_NAME); 1209 } 1210 bool KeyCompareLessThan(const Monster *o) const { 1211 return *name() < *o->name(); 1212 } 1213 int KeyCompareWithValue(const char *val) const { 1214 return strcmp(name()->c_str(), val); 1215 } 1216 const flatbuffers::Vector<uint8_t> *inventory() const { 1217 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); 1218 } 1219 flatbuffers::Vector<uint8_t> *mutable_inventory() { 1220 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); 1221 } 1222 Color color() const { 1223 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 8)); 1224 } 1225 bool mutate_color(Color _color) { 1226 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 8); 1227 } 1228 Any test_type() const { 1229 return static_cast<Any>(GetField<uint8_t>(VT_TEST_TYPE, 0)); 1230 } 1231 bool mutate_test_type(Any _test_type) { 1232 return SetField<uint8_t>(VT_TEST_TYPE, static_cast<uint8_t>(_test_type), 0); 1233 } 1234 const void *test() const { 1235 return GetPointer<const void *>(VT_TEST); 1236 } 1237 template<typename T> const T *test_as() const; 1238 const Monster *test_as_Monster() const { 1239 return test_type() == Any_Monster ? static_cast<const Monster *>(test()) : nullptr; 1240 } 1241 const TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const { 1242 return test_type() == Any_TestSimpleTableWithEnum ? static_cast<const TestSimpleTableWithEnum *>(test()) : nullptr; 1243 } 1244 const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const { 1245 return test_type() == Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr; 1246 } 1247 void *mutable_test() { 1248 return GetPointer<void *>(VT_TEST); 1249 } 1250 const flatbuffers::Vector<const Test *> *test4() const { 1251 return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST4); 1252 } 1253 flatbuffers::Vector<const Test *> *mutable_test4() { 1254 return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST4); 1255 } 1256 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring() const { 1257 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING); 1258 } 1259 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring() { 1260 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING); 1261 } 1262 /// an example documentation comment: this will end up in the generated code 1263 /// multiline too 1264 const flatbuffers::Vector<flatbuffers::Offset<Monster>> *testarrayoftables() const { 1265 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES); 1266 } 1267 flatbuffers::Vector<flatbuffers::Offset<Monster>> *mutable_testarrayoftables() { 1268 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES); 1269 } 1270 const Monster *enemy() const { 1271 return GetPointer<const Monster *>(VT_ENEMY); 1272 } 1273 Monster *mutable_enemy() { 1274 return GetPointer<Monster *>(VT_ENEMY); 1275 } 1276 const flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const { 1277 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER); 1278 } 1279 flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() { 1280 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER); 1281 } 1282 const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { 1283 return flatbuffers::GetRoot<MyGame::Example::Monster>(testnestedflatbuffer()->Data()); 1284 } 1285 const Stat *testempty() const { 1286 return GetPointer<const Stat *>(VT_TESTEMPTY); 1287 } 1288 Stat *mutable_testempty() { 1289 return GetPointer<Stat *>(VT_TESTEMPTY); 1290 } 1291 bool testbool() const { 1292 return GetField<uint8_t>(VT_TESTBOOL, 0) != 0; 1293 } 1294 bool mutate_testbool(bool _testbool) { 1295 return SetField<uint8_t>(VT_TESTBOOL, static_cast<uint8_t>(_testbool), 0); 1296 } 1297 int32_t testhashs32_fnv1() const { 1298 return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0); 1299 } 1300 bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) { 1301 return SetField<int32_t>(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0); 1302 } 1303 uint32_t testhashu32_fnv1() const { 1304 return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0); 1305 } 1306 bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) { 1307 return SetField<uint32_t>(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0); 1308 } 1309 int64_t testhashs64_fnv1() const { 1310 return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0); 1311 } 1312 bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) { 1313 return SetField<int64_t>(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0); 1314 } 1315 uint64_t testhashu64_fnv1() const { 1316 return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0); 1317 } 1318 bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) { 1319 return SetField<uint64_t>(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0); 1320 } 1321 int32_t testhashs32_fnv1a() const { 1322 return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0); 1323 } 1324 bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) { 1325 return SetField<int32_t>(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0); 1326 } 1327 uint32_t testhashu32_fnv1a() const { 1328 return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0); 1329 } 1330 bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) { 1331 return SetField<uint32_t>(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0); 1332 } 1333 int64_t testhashs64_fnv1a() const { 1334 return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0); 1335 } 1336 bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) { 1337 return SetField<int64_t>(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0); 1338 } 1339 uint64_t testhashu64_fnv1a() const { 1340 return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0); 1341 } 1342 bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) { 1343 return SetField<uint64_t>(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0); 1344 } 1345 const flatbuffers::Vector<uint8_t> *testarrayofbools() const { 1346 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS); 1347 } 1348 flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() { 1349 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS); 1350 } 1351 float testf() const { 1352 return GetField<float>(VT_TESTF, 3.14159f); 1353 } 1354 bool mutate_testf(float _testf) { 1355 return SetField<float>(VT_TESTF, _testf, 3.14159f); 1356 } 1357 float testf2() const { 1358 return GetField<float>(VT_TESTF2, 3.0f); 1359 } 1360 bool mutate_testf2(float _testf2) { 1361 return SetField<float>(VT_TESTF2, _testf2, 3.0f); 1362 } 1363 float testf3() const { 1364 return GetField<float>(VT_TESTF3, 0.0f); 1365 } 1366 bool mutate_testf3(float _testf3) { 1367 return SetField<float>(VT_TESTF3, _testf3, 0.0f); 1368 } 1369 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2() const { 1370 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2); 1371 } 1372 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring2() { 1373 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2); 1374 } 1375 const flatbuffers::Vector<const Ability *> *testarrayofsortedstruct() const { 1376 return GetPointer<const flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT); 1377 } 1378 flatbuffers::Vector<const Ability *> *mutable_testarrayofsortedstruct() { 1379 return GetPointer<flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT); 1380 } 1381 const flatbuffers::Vector<uint8_t> *flex() const { 1382 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_FLEX); 1383 } 1384 flatbuffers::Vector<uint8_t> *mutable_flex() { 1385 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_FLEX); 1386 } 1387 flexbuffers::Reference flex_flexbuffer_root() const { 1388 return flexbuffers::GetRoot(flex()->Data(), flex()->size()); 1389 } 1390 const flatbuffers::Vector<const Test *> *test5() const { 1391 return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST5); 1392 } 1393 flatbuffers::Vector<const Test *> *mutable_test5() { 1394 return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST5); 1395 } 1396 const flatbuffers::Vector<int64_t> *vector_of_longs() const { 1397 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS); 1398 } 1399 flatbuffers::Vector<int64_t> *mutable_vector_of_longs() { 1400 return GetPointer<flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS); 1401 } 1402 const flatbuffers::Vector<double> *vector_of_doubles() const { 1403 return GetPointer<const flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES); 1404 } 1405 flatbuffers::Vector<double> *mutable_vector_of_doubles() { 1406 return GetPointer<flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES); 1407 } 1408 const MyGame::InParentNamespace *parent_namespace_test() const { 1409 return GetPointer<const MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST); 1410 } 1411 MyGame::InParentNamespace *mutable_parent_namespace_test() { 1412 return GetPointer<MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST); 1413 } 1414 const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *vector_of_referrables() const { 1415 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES); 1416 } 1417 flatbuffers::Vector<flatbuffers::Offset<Referrable>> *mutable_vector_of_referrables() { 1418 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES); 1419 } 1420 uint64_t single_weak_reference() const { 1421 return GetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, 0); 1422 } 1423 bool mutate_single_weak_reference(uint64_t _single_weak_reference) { 1424 return SetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0); 1425 } 1426 const flatbuffers::Vector<uint64_t> *vector_of_weak_references() const { 1427 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES); 1428 } 1429 flatbuffers::Vector<uint64_t> *mutable_vector_of_weak_references() { 1430 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES); 1431 } 1432 const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *vector_of_strong_referrables() const { 1433 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES); 1434 } 1435 flatbuffers::Vector<flatbuffers::Offset<Referrable>> *mutable_vector_of_strong_referrables() { 1436 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES); 1437 } 1438 uint64_t co_owning_reference() const { 1439 return GetField<uint64_t>(VT_CO_OWNING_REFERENCE, 0); 1440 } 1441 bool mutate_co_owning_reference(uint64_t _co_owning_reference) { 1442 return SetField<uint64_t>(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0); 1443 } 1444 const flatbuffers::Vector<uint64_t> *vector_of_co_owning_references() const { 1445 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); 1446 } 1447 flatbuffers::Vector<uint64_t> *mutable_vector_of_co_owning_references() { 1448 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); 1449 } 1450 uint64_t non_owning_reference() const { 1451 return GetField<uint64_t>(VT_NON_OWNING_REFERENCE, 0); 1452 } 1453 bool mutate_non_owning_reference(uint64_t _non_owning_reference) { 1454 return SetField<uint64_t>(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0); 1455 } 1456 const flatbuffers::Vector<uint64_t> *vector_of_non_owning_references() const { 1457 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); 1458 } 1459 flatbuffers::Vector<uint64_t> *mutable_vector_of_non_owning_references() { 1460 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); 1461 } 1462 AnyUniqueAliases any_unique_type() const { 1463 return static_cast<AnyUniqueAliases>(GetField<uint8_t>(VT_ANY_UNIQUE_TYPE, 0)); 1464 } 1465 bool mutate_any_unique_type(AnyUniqueAliases _any_unique_type) { 1466 return SetField<uint8_t>(VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(_any_unique_type), 0); 1467 } 1468 const void *any_unique() const { 1469 return GetPointer<const void *>(VT_ANY_UNIQUE); 1470 } 1471 template<typename T> const T *any_unique_as() const; 1472 const Monster *any_unique_as_M() const { 1473 return any_unique_type() == AnyUniqueAliases_M ? static_cast<const Monster *>(any_unique()) : nullptr; 1474 } 1475 const TestSimpleTableWithEnum *any_unique_as_T() const { 1476 return any_unique_type() == AnyUniqueAliases_T ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr; 1477 } 1478 const MyGame::Example2::Monster *any_unique_as_M2() const { 1479 return any_unique_type() == AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr; 1480 } 1481 void *mutable_any_unique() { 1482 return GetPointer<void *>(VT_ANY_UNIQUE); 1483 } 1484 AnyAmbiguousAliases any_ambiguous_type() const { 1485 return static_cast<AnyAmbiguousAliases>(GetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, 0)); 1486 } 1487 bool mutate_any_ambiguous_type(AnyAmbiguousAliases _any_ambiguous_type) { 1488 return SetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(_any_ambiguous_type), 0); 1489 } 1490 const void *any_ambiguous() const { 1491 return GetPointer<const void *>(VT_ANY_AMBIGUOUS); 1492 } 1493 const Monster *any_ambiguous_as_M1() const { 1494 return any_ambiguous_type() == AnyAmbiguousAliases_M1 ? static_cast<const Monster *>(any_ambiguous()) : nullptr; 1495 } 1496 const Monster *any_ambiguous_as_M2() const { 1497 return any_ambiguous_type() == AnyAmbiguousAliases_M2 ? static_cast<const Monster *>(any_ambiguous()) : nullptr; 1498 } 1499 const Monster *any_ambiguous_as_M3() const { 1500 return any_ambiguous_type() == AnyAmbiguousAliases_M3 ? static_cast<const Monster *>(any_ambiguous()) : nullptr; 1501 } 1502 void *mutable_any_ambiguous() { 1503 return GetPointer<void *>(VT_ANY_AMBIGUOUS); 1504 } 1505 const flatbuffers::Vector<int8_t> *vector_of_enums() const { 1506 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS); 1507 } 1508 flatbuffers::Vector<int8_t> *mutable_vector_of_enums() { 1509 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS); 1510 } 1511 bool Verify(flatbuffers::Verifier &verifier) const { 1512 return VerifyTableStart(verifier) && 1513 VerifyField<Vec3>(verifier, VT_POS) && 1514 VerifyField<int16_t>(verifier, VT_MANA) && 1515 VerifyField<int16_t>(verifier, VT_HP) && 1516 VerifyOffsetRequired(verifier, VT_NAME) && 1517 verifier.VerifyString(name()) && 1518 VerifyOffset(verifier, VT_INVENTORY) && 1519 verifier.VerifyVector(inventory()) && 1520 VerifyField<int8_t>(verifier, VT_COLOR) && 1521 VerifyField<uint8_t>(verifier, VT_TEST_TYPE) && 1522 VerifyOffset(verifier, VT_TEST) && 1523 VerifyAny(verifier, test(), test_type()) && 1524 VerifyOffset(verifier, VT_TEST4) && 1525 verifier.VerifyVector(test4()) && 1526 VerifyOffset(verifier, VT_TESTARRAYOFSTRING) && 1527 verifier.VerifyVector(testarrayofstring()) && 1528 verifier.VerifyVectorOfStrings(testarrayofstring()) && 1529 VerifyOffset(verifier, VT_TESTARRAYOFTABLES) && 1530 verifier.VerifyVector(testarrayoftables()) && 1531 verifier.VerifyVectorOfTables(testarrayoftables()) && 1532 VerifyOffset(verifier, VT_ENEMY) && 1533 verifier.VerifyTable(enemy()) && 1534 VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) && 1535 verifier.VerifyVector(testnestedflatbuffer()) && 1536 VerifyOffset(verifier, VT_TESTEMPTY) && 1537 verifier.VerifyTable(testempty()) && 1538 VerifyField<uint8_t>(verifier, VT_TESTBOOL) && 1539 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) && 1540 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) && 1541 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) && 1542 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) && 1543 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) && 1544 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) && 1545 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) && 1546 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) && 1547 VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) && 1548 verifier.VerifyVector(testarrayofbools()) && 1549 VerifyField<float>(verifier, VT_TESTF) && 1550 VerifyField<float>(verifier, VT_TESTF2) && 1551 VerifyField<float>(verifier, VT_TESTF3) && 1552 VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) && 1553 verifier.VerifyVector(testarrayofstring2()) && 1554 verifier.VerifyVectorOfStrings(testarrayofstring2()) && 1555 VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) && 1556 verifier.VerifyVector(testarrayofsortedstruct()) && 1557 VerifyOffset(verifier, VT_FLEX) && 1558 verifier.VerifyVector(flex()) && 1559 VerifyOffset(verifier, VT_TEST5) && 1560 verifier.VerifyVector(test5()) && 1561 VerifyOffset(verifier, VT_VECTOR_OF_LONGS) && 1562 verifier.VerifyVector(vector_of_longs()) && 1563 VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) && 1564 verifier.VerifyVector(vector_of_doubles()) && 1565 VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) && 1566 verifier.VerifyTable(parent_namespace_test()) && 1567 VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) && 1568 verifier.VerifyVector(vector_of_referrables()) && 1569 verifier.VerifyVectorOfTables(vector_of_referrables()) && 1570 VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) && 1571 VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) && 1572 verifier.VerifyVector(vector_of_weak_references()) && 1573 VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) && 1574 verifier.VerifyVector(vector_of_strong_referrables()) && 1575 verifier.VerifyVectorOfTables(vector_of_strong_referrables()) && 1576 VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) && 1577 VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) && 1578 verifier.VerifyVector(vector_of_co_owning_references()) && 1579 VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) && 1580 VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) && 1581 verifier.VerifyVector(vector_of_non_owning_references()) && 1582 VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE) && 1583 VerifyOffset(verifier, VT_ANY_UNIQUE) && 1584 VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) && 1585 VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE) && 1586 VerifyOffset(verifier, VT_ANY_AMBIGUOUS) && 1587 VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) && 1588 VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) && 1589 verifier.VerifyVector(vector_of_enums()) && 1590 verifier.EndTable(); 1591 } 1592 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1593 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1594 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1595 }; 1596 1597 template<> inline const Monster *Monster::test_as<Monster>() const { 1598 return test_as_Monster(); 1599 } 1600 1601 template<> inline const TestSimpleTableWithEnum *Monster::test_as<TestSimpleTableWithEnum>() const { 1602 return test_as_TestSimpleTableWithEnum(); 1603 } 1604 1605 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const { 1606 return test_as_MyGame_Example2_Monster(); 1607 } 1608 1609 template<> inline const Monster *Monster::any_unique_as<Monster>() const { 1610 return any_unique_as_M(); 1611 } 1612 1613 template<> inline const TestSimpleTableWithEnum *Monster::any_unique_as<TestSimpleTableWithEnum>() const { 1614 return any_unique_as_T(); 1615 } 1616 1617 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const { 1618 return any_unique_as_M2(); 1619 } 1620 1621 struct MonsterBuilder { 1622 flatbuffers::FlatBufferBuilder &fbb_; 1623 flatbuffers::uoffset_t start_; 1624 void add_pos(const Vec3 *pos) { 1625 fbb_.AddStruct(Monster::VT_POS, pos); 1626 } 1627 void add_mana(int16_t mana) { 1628 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150); 1629 } 1630 void add_hp(int16_t hp) { 1631 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100); 1632 } 1633 void add_name(flatbuffers::Offset<flatbuffers::String> name) { 1634 fbb_.AddOffset(Monster::VT_NAME, name); 1635 } 1636 void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { 1637 fbb_.AddOffset(Monster::VT_INVENTORY, inventory); 1638 } 1639 void add_color(Color color) { 1640 fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 8); 1641 } 1642 void add_test_type(Any test_type) { 1643 fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0); 1644 } 1645 void add_test(flatbuffers::Offset<void> test) { 1646 fbb_.AddOffset(Monster::VT_TEST, test); 1647 } 1648 void add_test4(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4) { 1649 fbb_.AddOffset(Monster::VT_TEST4, test4); 1650 } 1651 void add_testarrayofstring(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring) { 1652 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); 1653 } 1654 void add_testarrayoftables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables) { 1655 fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); 1656 } 1657 void add_enemy(flatbuffers::Offset<Monster> enemy) { 1658 fbb_.AddOffset(Monster::VT_ENEMY, enemy); 1659 } 1660 void add_testnestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer) { 1661 fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); 1662 } 1663 void add_testempty(flatbuffers::Offset<Stat> testempty) { 1664 fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty); 1665 } 1666 void add_testbool(bool testbool) { 1667 fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0); 1668 } 1669 void add_testhashs32_fnv1(int32_t testhashs32_fnv1) { 1670 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); 1671 } 1672 void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) { 1673 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); 1674 } 1675 void add_testhashs64_fnv1(int64_t testhashs64_fnv1) { 1676 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); 1677 } 1678 void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) { 1679 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); 1680 } 1681 void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) { 1682 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); 1683 } 1684 void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) { 1685 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); 1686 } 1687 void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) { 1688 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); 1689 } 1690 void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) { 1691 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); 1692 } 1693 void add_testarrayofbools(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools) { 1694 fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); 1695 } 1696 void add_testf(float testf) { 1697 fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f); 1698 } 1699 void add_testf2(float testf2) { 1700 fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f); 1701 } 1702 void add_testf3(float testf3) { 1703 fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f); 1704 } 1705 void add_testarrayofstring2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2) { 1706 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); 1707 } 1708 void add_testarrayofsortedstruct(flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct) { 1709 fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); 1710 } 1711 void add_flex(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> flex) { 1712 fbb_.AddOffset(Monster::VT_FLEX, flex); 1713 } 1714 void add_test5(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test5) { 1715 fbb_.AddOffset(Monster::VT_TEST5, test5); 1716 } 1717 void add_vector_of_longs(flatbuffers::Offset<flatbuffers::Vector<int64_t>> vector_of_longs) { 1718 fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); 1719 } 1720 void add_vector_of_doubles(flatbuffers::Offset<flatbuffers::Vector<double>> vector_of_doubles) { 1721 fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles); 1722 } 1723 void add_parent_namespace_test(flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test) { 1724 fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); 1725 } 1726 void add_vector_of_referrables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables) { 1727 fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables); 1728 } 1729 void add_single_weak_reference(uint64_t single_weak_reference) { 1730 fbb_.AddElement<uint64_t>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0); 1731 } 1732 void add_vector_of_weak_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references) { 1733 fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references); 1734 } 1735 void add_vector_of_strong_referrables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_strong_referrables) { 1736 fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables); 1737 } 1738 void add_co_owning_reference(uint64_t co_owning_reference) { 1739 fbb_.AddElement<uint64_t>(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0); 1740 } 1741 void add_vector_of_co_owning_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_co_owning_references) { 1742 fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references); 1743 } 1744 void add_non_owning_reference(uint64_t non_owning_reference) { 1745 fbb_.AddElement<uint64_t>(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0); 1746 } 1747 void add_vector_of_non_owning_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_non_owning_references) { 1748 fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references); 1749 } 1750 void add_any_unique_type(AnyUniqueAliases any_unique_type) { 1751 fbb_.AddElement<uint8_t>(Monster::VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(any_unique_type), 0); 1752 } 1753 void add_any_unique(flatbuffers::Offset<void> any_unique) { 1754 fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique); 1755 } 1756 void add_any_ambiguous_type(AnyAmbiguousAliases any_ambiguous_type) { 1757 fbb_.AddElement<uint8_t>(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(any_ambiguous_type), 0); 1758 } 1759 void add_any_ambiguous(flatbuffers::Offset<void> any_ambiguous) { 1760 fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); 1761 } 1762 void add_vector_of_enums(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums) { 1763 fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums); 1764 } 1765 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1766 : fbb_(_fbb) { 1767 start_ = fbb_.StartTable(); 1768 } 1769 MonsterBuilder &operator=(const MonsterBuilder &); 1770 flatbuffers::Offset<Monster> Finish() { 1771 const auto end = fbb_.EndTable(start_); 1772 auto o = flatbuffers::Offset<Monster>(end); 1773 fbb_.Required(o, Monster::VT_NAME); 1774 return o; 1775 } 1776 }; 1777 1778 inline flatbuffers::Offset<Monster> CreateMonster( 1779 flatbuffers::FlatBufferBuilder &_fbb, 1780 const Vec3 *pos = 0, 1781 int16_t mana = 150, 1782 int16_t hp = 100, 1783 flatbuffers::Offset<flatbuffers::String> name = 0, 1784 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0, 1785 Color color = Color_Blue, 1786 Any test_type = Any_NONE, 1787 flatbuffers::Offset<void> test = 0, 1788 flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4 = 0, 1789 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring = 0, 1790 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables = 0, 1791 flatbuffers::Offset<Monster> enemy = 0, 1792 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0, 1793 flatbuffers::Offset<Stat> testempty = 0, 1794 bool testbool = false, 1795 int32_t testhashs32_fnv1 = 0, 1796 uint32_t testhashu32_fnv1 = 0, 1797 int64_t testhashs64_fnv1 = 0, 1798 uint64_t testhashu64_fnv1 = 0, 1799 int32_t testhashs32_fnv1a = 0, 1800 uint32_t testhashu32_fnv1a = 0, 1801 int64_t testhashs64_fnv1a = 0, 1802 uint64_t testhashu64_fnv1a = 0, 1803 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools = 0, 1804 float testf = 3.14159f, 1805 float testf2 = 3.0f, 1806 float testf3 = 0.0f, 1807 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2 = 0, 1808 flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct = 0, 1809 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> flex = 0, 1810 flatbuffers::Offset<flatbuffers::Vector<const Test *>> test5 = 0, 1811 flatbuffers::Offset<flatbuffers::Vector<int64_t>> vector_of_longs = 0, 1812 flatbuffers::Offset<flatbuffers::Vector<double>> vector_of_doubles = 0, 1813 flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0, 1814 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables = 0, 1815 uint64_t single_weak_reference = 0, 1816 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0, 1817 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_strong_referrables = 0, 1818 uint64_t co_owning_reference = 0, 1819 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_co_owning_references = 0, 1820 uint64_t non_owning_reference = 0, 1821 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_non_owning_references = 0, 1822 AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE, 1823 flatbuffers::Offset<void> any_unique = 0, 1824 AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE, 1825 flatbuffers::Offset<void> any_ambiguous = 0, 1826 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums = 0) { 1827 MonsterBuilder builder_(_fbb); 1828 builder_.add_non_owning_reference(non_owning_reference); 1829 builder_.add_co_owning_reference(co_owning_reference); 1830 builder_.add_single_weak_reference(single_weak_reference); 1831 builder_.add_testhashu64_fnv1a(testhashu64_fnv1a); 1832 builder_.add_testhashs64_fnv1a(testhashs64_fnv1a); 1833 builder_.add_testhashu64_fnv1(testhashu64_fnv1); 1834 builder_.add_testhashs64_fnv1(testhashs64_fnv1); 1835 builder_.add_vector_of_enums(vector_of_enums); 1836 builder_.add_any_ambiguous(any_ambiguous); 1837 builder_.add_any_unique(any_unique); 1838 builder_.add_vector_of_non_owning_references(vector_of_non_owning_references); 1839 builder_.add_vector_of_co_owning_references(vector_of_co_owning_references); 1840 builder_.add_vector_of_strong_referrables(vector_of_strong_referrables); 1841 builder_.add_vector_of_weak_references(vector_of_weak_references); 1842 builder_.add_vector_of_referrables(vector_of_referrables); 1843 builder_.add_parent_namespace_test(parent_namespace_test); 1844 builder_.add_vector_of_doubles(vector_of_doubles); 1845 builder_.add_vector_of_longs(vector_of_longs); 1846 builder_.add_test5(test5); 1847 builder_.add_flex(flex); 1848 builder_.add_testarrayofsortedstruct(testarrayofsortedstruct); 1849 builder_.add_testarrayofstring2(testarrayofstring2); 1850 builder_.add_testf3(testf3); 1851 builder_.add_testf2(testf2); 1852 builder_.add_testf(testf); 1853 builder_.add_testarrayofbools(testarrayofbools); 1854 builder_.add_testhashu32_fnv1a(testhashu32_fnv1a); 1855 builder_.add_testhashs32_fnv1a(testhashs32_fnv1a); 1856 builder_.add_testhashu32_fnv1(testhashu32_fnv1); 1857 builder_.add_testhashs32_fnv1(testhashs32_fnv1); 1858 builder_.add_testempty(testempty); 1859 builder_.add_testnestedflatbuffer(testnestedflatbuffer); 1860 builder_.add_enemy(enemy); 1861 builder_.add_testarrayoftables(testarrayoftables); 1862 builder_.add_testarrayofstring(testarrayofstring); 1863 builder_.add_test4(test4); 1864 builder_.add_test(test); 1865 builder_.add_inventory(inventory); 1866 builder_.add_name(name); 1867 builder_.add_pos(pos); 1868 builder_.add_hp(hp); 1869 builder_.add_mana(mana); 1870 builder_.add_any_ambiguous_type(any_ambiguous_type); 1871 builder_.add_any_unique_type(any_unique_type); 1872 builder_.add_testbool(testbool); 1873 builder_.add_test_type(test_type); 1874 builder_.add_color(color); 1875 return builder_.Finish(); 1876 } 1877 1878 inline flatbuffers::Offset<Monster> CreateMonsterDirect( 1879 flatbuffers::FlatBufferBuilder &_fbb, 1880 const Vec3 *pos = 0, 1881 int16_t mana = 150, 1882 int16_t hp = 100, 1883 const char *name = nullptr, 1884 const std::vector<uint8_t> *inventory = nullptr, 1885 Color color = Color_Blue, 1886 Any test_type = Any_NONE, 1887 flatbuffers::Offset<void> test = 0, 1888 const std::vector<Test> *test4 = nullptr, 1889 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring = nullptr, 1890 const std::vector<flatbuffers::Offset<Monster>> *testarrayoftables = nullptr, 1891 flatbuffers::Offset<Monster> enemy = 0, 1892 const std::vector<uint8_t> *testnestedflatbuffer = nullptr, 1893 flatbuffers::Offset<Stat> testempty = 0, 1894 bool testbool = false, 1895 int32_t testhashs32_fnv1 = 0, 1896 uint32_t testhashu32_fnv1 = 0, 1897 int64_t testhashs64_fnv1 = 0, 1898 uint64_t testhashu64_fnv1 = 0, 1899 int32_t testhashs32_fnv1a = 0, 1900 uint32_t testhashu32_fnv1a = 0, 1901 int64_t testhashs64_fnv1a = 0, 1902 uint64_t testhashu64_fnv1a = 0, 1903 const std::vector<uint8_t> *testarrayofbools = nullptr, 1904 float testf = 3.14159f, 1905 float testf2 = 3.0f, 1906 float testf3 = 0.0f, 1907 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2 = nullptr, 1908 const std::vector<Ability> *testarrayofsortedstruct = nullptr, 1909 const std::vector<uint8_t> *flex = nullptr, 1910 const std::vector<Test> *test5 = nullptr, 1911 const std::vector<int64_t> *vector_of_longs = nullptr, 1912 const std::vector<double> *vector_of_doubles = nullptr, 1913 flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0, 1914 const std::vector<flatbuffers::Offset<Referrable>> *vector_of_referrables = nullptr, 1915 uint64_t single_weak_reference = 0, 1916 const std::vector<uint64_t> *vector_of_weak_references = nullptr, 1917 const std::vector<flatbuffers::Offset<Referrable>> *vector_of_strong_referrables = nullptr, 1918 uint64_t co_owning_reference = 0, 1919 const std::vector<uint64_t> *vector_of_co_owning_references = nullptr, 1920 uint64_t non_owning_reference = 0, 1921 const std::vector<uint64_t> *vector_of_non_owning_references = nullptr, 1922 AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE, 1923 flatbuffers::Offset<void> any_unique = 0, 1924 AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE, 1925 flatbuffers::Offset<void> any_ambiguous = 0, 1926 const std::vector<int8_t> *vector_of_enums = nullptr) { 1927 auto name__ = name ? _fbb.CreateString(name) : 0; 1928 auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0; 1929 auto test4__ = test4 ? _fbb.CreateVectorOfStructs<Test>(*test4) : 0; 1930 auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring) : 0; 1931 auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVector<flatbuffers::Offset<Monster>>(*testarrayoftables) : 0; 1932 auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0; 1933 auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0; 1934 auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring2) : 0; 1935 auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfStructs<Ability>(*testarrayofsortedstruct) : 0; 1936 auto flex__ = flex ? _fbb.CreateVector<uint8_t>(*flex) : 0; 1937 auto test5__ = test5 ? _fbb.CreateVectorOfStructs<Test>(*test5) : 0; 1938 auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector<int64_t>(*vector_of_longs) : 0; 1939 auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector<double>(*vector_of_doubles) : 0; 1940 auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVector<flatbuffers::Offset<Referrable>>(*vector_of_referrables) : 0; 1941 auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector<uint64_t>(*vector_of_weak_references) : 0; 1942 auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVector<flatbuffers::Offset<Referrable>>(*vector_of_strong_referrables) : 0; 1943 auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0; 1944 auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0; 1945 auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<int8_t>(*vector_of_enums) : 0; 1946 return MyGame::Example::CreateMonster( 1947 _fbb, 1948 pos, 1949 mana, 1950 hp, 1951 name__, 1952 inventory__, 1953 color, 1954 test_type, 1955 test, 1956 test4__, 1957 testarrayofstring__, 1958 testarrayoftables__, 1959 enemy, 1960 testnestedflatbuffer__, 1961 testempty, 1962 testbool, 1963 testhashs32_fnv1, 1964 testhashu32_fnv1, 1965 testhashs64_fnv1, 1966 testhashu64_fnv1, 1967 testhashs32_fnv1a, 1968 testhashu32_fnv1a, 1969 testhashs64_fnv1a, 1970 testhashu64_fnv1a, 1971 testarrayofbools__, 1972 testf, 1973 testf2, 1974 testf3, 1975 testarrayofstring2__, 1976 testarrayofsortedstruct__, 1977 flex__, 1978 test5__, 1979 vector_of_longs__, 1980 vector_of_doubles__, 1981 parent_namespace_test, 1982 vector_of_referrables__, 1983 single_weak_reference, 1984 vector_of_weak_references__, 1985 vector_of_strong_referrables__, 1986 co_owning_reference, 1987 vector_of_co_owning_references__, 1988 non_owning_reference, 1989 vector_of_non_owning_references__, 1990 any_unique_type, 1991 any_unique, 1992 any_ambiguous_type, 1993 any_ambiguous, 1994 vector_of_enums__); 1995 } 1996 1997 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1998 1999 struct TypeAliasesT : public flatbuffers::NativeTable { 2000 typedef TypeAliases TableType; 2001 int8_t i8; 2002 uint8_t u8; 2003 int16_t i16; 2004 uint16_t u16; 2005 int32_t i32; 2006 uint32_t u32; 2007 int64_t i64; 2008 uint64_t u64; 2009 float f32; 2010 double f64; 2011 std::vector<int8_t> v8; 2012 std::vector<double> vf64; 2013 TypeAliasesT() 2014 : i8(0), 2015 u8(0), 2016 i16(0), 2017 u16(0), 2018 i32(0), 2019 u32(0), 2020 i64(0), 2021 u64(0), 2022 f32(0.0f), 2023 f64(0.0) { 2024 } 2025 }; 2026 2027 inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { 2028 return 2029 (lhs.i8 == rhs.i8) && 2030 (lhs.u8 == rhs.u8) && 2031 (lhs.i16 == rhs.i16) && 2032 (lhs.u16 == rhs.u16) && 2033 (lhs.i32 == rhs.i32) && 2034 (lhs.u32 == rhs.u32) && 2035 (lhs.i64 == rhs.i64) && 2036 (lhs.u64 == rhs.u64) && 2037 (lhs.f32 == rhs.f32) && 2038 (lhs.f64 == rhs.f64) && 2039 (lhs.v8 == rhs.v8) && 2040 (lhs.vf64 == rhs.vf64); 2041 } 2042 2043 struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2044 typedef TypeAliasesT NativeTableType; 2045 static const flatbuffers::TypeTable *MiniReflectTypeTable() { 2046 return TypeAliasesTypeTable(); 2047 } 2048 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2049 VT_I8 = 4, 2050 VT_U8 = 6, 2051 VT_I16 = 8, 2052 VT_U16 = 10, 2053 VT_I32 = 12, 2054 VT_U32 = 14, 2055 VT_I64 = 16, 2056 VT_U64 = 18, 2057 VT_F32 = 20, 2058 VT_F64 = 22, 2059 VT_V8 = 24, 2060 VT_VF64 = 26 2061 }; 2062 int8_t i8() const { 2063 return GetField<int8_t>(VT_I8, 0); 2064 } 2065 bool mutate_i8(int8_t _i8) { 2066 return SetField<int8_t>(VT_I8, _i8, 0); 2067 } 2068 uint8_t u8() const { 2069 return GetField<uint8_t>(VT_U8, 0); 2070 } 2071 bool mutate_u8(uint8_t _u8) { 2072 return SetField<uint8_t>(VT_U8, _u8, 0); 2073 } 2074 int16_t i16() const { 2075 return GetField<int16_t>(VT_I16, 0); 2076 } 2077 bool mutate_i16(int16_t _i16) { 2078 return SetField<int16_t>(VT_I16, _i16, 0); 2079 } 2080 uint16_t u16() const { 2081 return GetField<uint16_t>(VT_U16, 0); 2082 } 2083 bool mutate_u16(uint16_t _u16) { 2084 return SetField<uint16_t>(VT_U16, _u16, 0); 2085 } 2086 int32_t i32() const { 2087 return GetField<int32_t>(VT_I32, 0); 2088 } 2089 bool mutate_i32(int32_t _i32) { 2090 return SetField<int32_t>(VT_I32, _i32, 0); 2091 } 2092 uint32_t u32() const { 2093 return GetField<uint32_t>(VT_U32, 0); 2094 } 2095 bool mutate_u32(uint32_t _u32) { 2096 return SetField<uint32_t>(VT_U32, _u32, 0); 2097 } 2098 int64_t i64() const { 2099 return GetField<int64_t>(VT_I64, 0); 2100 } 2101 bool mutate_i64(int64_t _i64) { 2102 return SetField<int64_t>(VT_I64, _i64, 0); 2103 } 2104 uint64_t u64() const { 2105 return GetField<uint64_t>(VT_U64, 0); 2106 } 2107 bool mutate_u64(uint64_t _u64) { 2108 return SetField<uint64_t>(VT_U64, _u64, 0); 2109 } 2110 float f32() const { 2111 return GetField<float>(VT_F32, 0.0f); 2112 } 2113 bool mutate_f32(float _f32) { 2114 return SetField<float>(VT_F32, _f32, 0.0f); 2115 } 2116 double f64() const { 2117 return GetField<double>(VT_F64, 0.0); 2118 } 2119 bool mutate_f64(double _f64) { 2120 return SetField<double>(VT_F64, _f64, 0.0); 2121 } 2122 const flatbuffers::Vector<int8_t> *v8() const { 2123 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_V8); 2124 } 2125 flatbuffers::Vector<int8_t> *mutable_v8() { 2126 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_V8); 2127 } 2128 const flatbuffers::Vector<double> *vf64() const { 2129 return GetPointer<const flatbuffers::Vector<double> *>(VT_VF64); 2130 } 2131 flatbuffers::Vector<double> *mutable_vf64() { 2132 return GetPointer<flatbuffers::Vector<double> *>(VT_VF64); 2133 } 2134 bool Verify(flatbuffers::Verifier &verifier) const { 2135 return VerifyTableStart(verifier) && 2136 VerifyField<int8_t>(verifier, VT_I8) && 2137 VerifyField<uint8_t>(verifier, VT_U8) && 2138 VerifyField<int16_t>(verifier, VT_I16) && 2139 VerifyField<uint16_t>(verifier, VT_U16) && 2140 VerifyField<int32_t>(verifier, VT_I32) && 2141 VerifyField<uint32_t>(verifier, VT_U32) && 2142 VerifyField<int64_t>(verifier, VT_I64) && 2143 VerifyField<uint64_t>(verifier, VT_U64) && 2144 VerifyField<float>(verifier, VT_F32) && 2145 VerifyField<double>(verifier, VT_F64) && 2146 VerifyOffset(verifier, VT_V8) && 2147 verifier.VerifyVector(v8()) && 2148 VerifyOffset(verifier, VT_VF64) && 2149 verifier.VerifyVector(vf64()) && 2150 verifier.EndTable(); 2151 } 2152 TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2153 void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2154 static flatbuffers::Offset<TypeAliases> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2155 }; 2156 2157 struct TypeAliasesBuilder { 2158 flatbuffers::FlatBufferBuilder &fbb_; 2159 flatbuffers::uoffset_t start_; 2160 void add_i8(int8_t i8) { 2161 fbb_.AddElement<int8_t>(TypeAliases::VT_I8, i8, 0); 2162 } 2163 void add_u8(uint8_t u8) { 2164 fbb_.AddElement<uint8_t>(TypeAliases::VT_U8, u8, 0); 2165 } 2166 void add_i16(int16_t i16) { 2167 fbb_.AddElement<int16_t>(TypeAliases::VT_I16, i16, 0); 2168 } 2169 void add_u16(uint16_t u16) { 2170 fbb_.AddElement<uint16_t>(TypeAliases::VT_U16, u16, 0); 2171 } 2172 void add_i32(int32_t i32) { 2173 fbb_.AddElement<int32_t>(TypeAliases::VT_I32, i32, 0); 2174 } 2175 void add_u32(uint32_t u32) { 2176 fbb_.AddElement<uint32_t>(TypeAliases::VT_U32, u32, 0); 2177 } 2178 void add_i64(int64_t i64) { 2179 fbb_.AddElement<int64_t>(TypeAliases::VT_I64, i64, 0); 2180 } 2181 void add_u64(uint64_t u64) { 2182 fbb_.AddElement<uint64_t>(TypeAliases::VT_U64, u64, 0); 2183 } 2184 void add_f32(float f32) { 2185 fbb_.AddElement<float>(TypeAliases::VT_F32, f32, 0.0f); 2186 } 2187 void add_f64(double f64) { 2188 fbb_.AddElement<double>(TypeAliases::VT_F64, f64, 0.0); 2189 } 2190 void add_v8(flatbuffers::Offset<flatbuffers::Vector<int8_t>> v8) { 2191 fbb_.AddOffset(TypeAliases::VT_V8, v8); 2192 } 2193 void add_vf64(flatbuffers::Offset<flatbuffers::Vector<double>> vf64) { 2194 fbb_.AddOffset(TypeAliases::VT_VF64, vf64); 2195 } 2196 explicit TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2197 : fbb_(_fbb) { 2198 start_ = fbb_.StartTable(); 2199 } 2200 TypeAliasesBuilder &operator=(const TypeAliasesBuilder &); 2201 flatbuffers::Offset<TypeAliases> Finish() { 2202 const auto end = fbb_.EndTable(start_); 2203 auto o = flatbuffers::Offset<TypeAliases>(end); 2204 return o; 2205 } 2206 }; 2207 2208 inline flatbuffers::Offset<TypeAliases> CreateTypeAliases( 2209 flatbuffers::FlatBufferBuilder &_fbb, 2210 int8_t i8 = 0, 2211 uint8_t u8 = 0, 2212 int16_t i16 = 0, 2213 uint16_t u16 = 0, 2214 int32_t i32 = 0, 2215 uint32_t u32 = 0, 2216 int64_t i64 = 0, 2217 uint64_t u64 = 0, 2218 float f32 = 0.0f, 2219 double f64 = 0.0, 2220 flatbuffers::Offset<flatbuffers::Vector<int8_t>> v8 = 0, 2221 flatbuffers::Offset<flatbuffers::Vector<double>> vf64 = 0) { 2222 TypeAliasesBuilder builder_(_fbb); 2223 builder_.add_f64(f64); 2224 builder_.add_u64(u64); 2225 builder_.add_i64(i64); 2226 builder_.add_vf64(vf64); 2227 builder_.add_v8(v8); 2228 builder_.add_f32(f32); 2229 builder_.add_u32(u32); 2230 builder_.add_i32(i32); 2231 builder_.add_u16(u16); 2232 builder_.add_i16(i16); 2233 builder_.add_u8(u8); 2234 builder_.add_i8(i8); 2235 return builder_.Finish(); 2236 } 2237 2238 inline flatbuffers::Offset<TypeAliases> CreateTypeAliasesDirect( 2239 flatbuffers::FlatBufferBuilder &_fbb, 2240 int8_t i8 = 0, 2241 uint8_t u8 = 0, 2242 int16_t i16 = 0, 2243 uint16_t u16 = 0, 2244 int32_t i32 = 0, 2245 uint32_t u32 = 0, 2246 int64_t i64 = 0, 2247 uint64_t u64 = 0, 2248 float f32 = 0.0f, 2249 double f64 = 0.0, 2250 const std::vector<int8_t> *v8 = nullptr, 2251 const std::vector<double> *vf64 = nullptr) { 2252 auto v8__ = v8 ? _fbb.CreateVector<int8_t>(*v8) : 0; 2253 auto vf64__ = vf64 ? _fbb.CreateVector<double>(*vf64) : 0; 2254 return MyGame::Example::CreateTypeAliases( 2255 _fbb, 2256 i8, 2257 u8, 2258 i16, 2259 u16, 2260 i32, 2261 u32, 2262 i64, 2263 u64, 2264 f32, 2265 f64, 2266 v8__, 2267 vf64__); 2268 } 2269 2270 flatbuffers::Offset<TypeAliases> CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2271 2272 } // namespace Example 2273 2274 inline InParentNamespaceT *InParentNamespace::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2275 auto _o = new InParentNamespaceT(); 2276 UnPackTo(_o, _resolver); 2277 return _o; 2278 } 2279 2280 inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2281 (void)_o; 2282 (void)_resolver; 2283 } 2284 2285 inline flatbuffers::Offset<InParentNamespace> InParentNamespace::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2286 return CreateInParentNamespace(_fbb, _o, _rehasher); 2287 } 2288 2289 inline flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2290 (void)_rehasher; 2291 (void)_o; 2292 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2293 return MyGame::CreateInParentNamespace( 2294 _fbb); 2295 } 2296 2297 namespace Example2 { 2298 2299 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2300 auto _o = new MonsterT(); 2301 UnPackTo(_o, _resolver); 2302 return _o; 2303 } 2304 2305 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2306 (void)_o; 2307 (void)_resolver; 2308 } 2309 2310 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2311 return CreateMonster(_fbb, _o, _rehasher); 2312 } 2313 2314 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2315 (void)_rehasher; 2316 (void)_o; 2317 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2318 return MyGame::Example2::CreateMonster( 2319 _fbb); 2320 } 2321 2322 } // namespace Example2 2323 2324 namespace Example { 2325 2326 inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2327 auto _o = new TestSimpleTableWithEnumT(); 2328 UnPackTo(_o, _resolver); 2329 return _o; 2330 } 2331 2332 inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2333 (void)_o; 2334 (void)_resolver; 2335 { auto _e = color(); _o->color = _e; }; 2336 } 2337 2338 inline flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2339 return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); 2340 } 2341 2342 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2343 (void)_rehasher; 2344 (void)_o; 2345 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2346 auto _color = _o->color; 2347 return MyGame::Example::CreateTestSimpleTableWithEnum( 2348 _fbb, 2349 _color); 2350 } 2351 2352 inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2353 auto _o = new StatT(); 2354 UnPackTo(_o, _resolver); 2355 return _o; 2356 } 2357 2358 inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2359 (void)_o; 2360 (void)_resolver; 2361 { auto _e = id(); if (_e) _o->id = _e->str(); }; 2362 { auto _e = val(); _o->val = _e; }; 2363 { auto _e = count(); _o->count = _e; }; 2364 } 2365 2366 inline flatbuffers::Offset<Stat> Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2367 return CreateStat(_fbb, _o, _rehasher); 2368 } 2369 2370 inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2371 (void)_rehasher; 2372 (void)_o; 2373 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2374 auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id); 2375 auto _val = _o->val; 2376 auto _count = _o->count; 2377 return MyGame::Example::CreateStat( 2378 _fbb, 2379 _id, 2380 _val, 2381 _count); 2382 } 2383 2384 inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2385 auto _o = new ReferrableT(); 2386 UnPackTo(_o, _resolver); 2387 return _o; 2388 } 2389 2390 inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2391 (void)_o; 2392 (void)_resolver; 2393 { auto _e = id(); _o->id = _e; }; 2394 } 2395 2396 inline flatbuffers::Offset<Referrable> Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2397 return CreateReferrable(_fbb, _o, _rehasher); 2398 } 2399 2400 inline flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2401 (void)_rehasher; 2402 (void)_o; 2403 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2404 auto _id = _o->id; 2405 return MyGame::Example::CreateReferrable( 2406 _fbb, 2407 _id); 2408 } 2409 2410 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2411 auto _o = new MonsterT(); 2412 UnPackTo(_o, _resolver); 2413 return _o; 2414 } 2415 2416 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2417 (void)_o; 2418 (void)_resolver; 2419 { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<Vec3>(new Vec3(*_e)); }; 2420 { auto _e = mana(); _o->mana = _e; }; 2421 { auto _e = hp(); _o->hp = _e; }; 2422 { auto _e = name(); if (_e) _o->name = _e->str(); }; 2423 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory[_i] = _e->Get(_i); } } }; 2424 { auto _e = color(); _o->color = _e; }; 2425 { auto _e = test_type(); _o->test.type = _e; }; 2426 { auto _e = test(); if (_e) _o->test.value = AnyUnion::UnPack(_e, test_type(), _resolver); }; 2427 { auto _e = test4(); if (_e) { _o->test4.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4[_i] = *_e->Get(_i); } } }; 2428 { auto _e = testarrayofstring(); if (_e) { _o->testarrayofstring.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring[_i] = _e->Get(_i)->str(); } } }; 2429 { auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = flatbuffers::unique_ptr<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } }; 2430 { auto _e = enemy(); if (_e) _o->enemy = flatbuffers::unique_ptr<MonsterT>(_e->UnPack(_resolver)); }; 2431 { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer[_i] = _e->Get(_i); } } }; 2432 { auto _e = testempty(); if (_e) _o->testempty = flatbuffers::unique_ptr<StatT>(_e->UnPack(_resolver)); }; 2433 { auto _e = testbool(); _o->testbool = _e; }; 2434 { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }; 2435 { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; }; 2436 { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; }; 2437 { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; }; 2438 { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; }; 2439 { auto _e = testhashu32_fnv1a(); //scalar resolver, naked 2440 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->testhashu32_fnv1a), static_cast<flatbuffers::hash_value_t>(_e)); else _o->testhashu32_fnv1a = nullptr; }; 2441 { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; }; 2442 { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; }; 2443 { auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } }; 2444 { auto _e = testf(); _o->testf = _e; }; 2445 { auto _e = testf2(); _o->testf2 = _e; }; 2446 { auto _e = testf3(); _o->testf3 = _e; }; 2447 { auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } }; 2448 { auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } }; 2449 { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->flex[_i] = _e->Get(_i); } } }; 2450 { auto _e = test5(); if (_e) { _o->test5.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test5[_i] = *_e->Get(_i); } } }; 2451 { auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } }; 2452 { auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } }; 2453 { auto _e = parent_namespace_test(); if (_e) _o->parent_namespace_test = flatbuffers::unique_ptr<MyGame::InParentNamespaceT>(_e->UnPack(_resolver)); }; 2454 { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } }; 2455 { auto _e = single_weak_reference(); //scalar resolver, naked 2456 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->single_weak_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->single_weak_reference = nullptr; }; 2457 { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked 2458 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_weak_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } }; 2459 { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } }; 2460 { auto _e = co_owning_reference(); //scalar resolver, naked 2461 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->co_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->co_owning_reference = nullptr; }; 2462 { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, default_ptr_type 2463 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_co_owning_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i)));/* else do nothing */; } } }; 2464 { auto _e = non_owning_reference(); //scalar resolver, naked 2465 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->non_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->non_owning_reference = nullptr; }; 2466 { auto _e = vector_of_non_owning_references(); if (_e) { _o->vector_of_non_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked 2467 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_non_owning_references[_i] = nullptr; } } }; 2468 { auto _e = any_unique_type(); _o->any_unique.type = _e; }; 2469 { auto _e = any_unique(); if (_e) _o->any_unique.value = AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); }; 2470 { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; }; 2471 { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }; 2472 { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<Color>(_e->Get(_i)); } } }; 2473 } 2474 2475 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2476 return CreateMonster(_fbb, _o, _rehasher); 2477 } 2478 2479 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2480 (void)_rehasher; 2481 (void)_o; 2482 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2483 auto _pos = _o->pos ? _o->pos.get() : 0; 2484 auto _mana = _o->mana; 2485 auto _hp = _o->hp; 2486 auto _name = _fbb.CreateString(_o->name); 2487 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; 2488 auto _color = _o->color; 2489 auto _test_type = _o->test.type; 2490 auto _test = _o->test.Pack(_fbb); 2491 auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0; 2492 auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0; 2493 auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<flatbuffers::Offset<Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0; 2494 auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0; 2495 auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0; 2496 auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0; 2497 auto _testbool = _o->testbool; 2498 auto _testhashs32_fnv1 = _o->testhashs32_fnv1; 2499 auto _testhashu32_fnv1 = _o->testhashu32_fnv1; 2500 auto _testhashs64_fnv1 = _o->testhashs64_fnv1; 2501 auto _testhashu64_fnv1 = _o->testhashu64_fnv1; 2502 auto _testhashs32_fnv1a = _o->testhashs32_fnv1a; 2503 auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0; 2504 auto _testhashs64_fnv1a = _o->testhashs64_fnv1a; 2505 auto _testhashu64_fnv1a = _o->testhashu64_fnv1a; 2506 auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0; 2507 auto _testf = _o->testf; 2508 auto _testf2 = _o->testf2; 2509 auto _testf3 = _o->testf3; 2510 auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0; 2511 auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0; 2512 auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0; 2513 auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0; 2514 auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0; 2515 auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0; 2516 auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0; 2517 auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<flatbuffers::Offset<Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; 2518 auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0; 2519 auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0; 2520 auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<flatbuffers::Offset<Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; 2521 auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0; 2522 auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0; 2523 auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0; 2524 auto _vector_of_non_owning_references = _o->vector_of_non_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_non_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_non_owning_references[i])) : 0; }, &_va ) : 0; 2525 auto _any_unique_type = _o->any_unique.type; 2526 auto _any_unique = _o->any_unique.Pack(_fbb); 2527 auto _any_ambiguous_type = _o->any_ambiguous.type; 2528 auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb); 2529 auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast<int8_t>(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0; 2530 return MyGame::Example::CreateMonster( 2531 _fbb, 2532 _pos, 2533 _mana, 2534 _hp, 2535 _name, 2536 _inventory, 2537 _color, 2538 _test_type, 2539 _test, 2540 _test4, 2541 _testarrayofstring, 2542 _testarrayoftables, 2543 _enemy, 2544 _testnestedflatbuffer, 2545 _testempty, 2546 _testbool, 2547 _testhashs32_fnv1, 2548 _testhashu32_fnv1, 2549 _testhashs64_fnv1, 2550 _testhashu64_fnv1, 2551 _testhashs32_fnv1a, 2552 _testhashu32_fnv1a, 2553 _testhashs64_fnv1a, 2554 _testhashu64_fnv1a, 2555 _testarrayofbools, 2556 _testf, 2557 _testf2, 2558 _testf3, 2559 _testarrayofstring2, 2560 _testarrayofsortedstruct, 2561 _flex, 2562 _test5, 2563 _vector_of_longs, 2564 _vector_of_doubles, 2565 _parent_namespace_test, 2566 _vector_of_referrables, 2567 _single_weak_reference, 2568 _vector_of_weak_references, 2569 _vector_of_strong_referrables, 2570 _co_owning_reference, 2571 _vector_of_co_owning_references, 2572 _non_owning_reference, 2573 _vector_of_non_owning_references, 2574 _any_unique_type, 2575 _any_unique, 2576 _any_ambiguous_type, 2577 _any_ambiguous, 2578 _vector_of_enums); 2579 } 2580 2581 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2582 auto _o = new TypeAliasesT(); 2583 UnPackTo(_o, _resolver); 2584 return _o; 2585 } 2586 2587 inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2588 (void)_o; 2589 (void)_resolver; 2590 { auto _e = i8(); _o->i8 = _e; }; 2591 { auto _e = u8(); _o->u8 = _e; }; 2592 { auto _e = i16(); _o->i16 = _e; }; 2593 { auto _e = u16(); _o->u16 = _e; }; 2594 { auto _e = i32(); _o->i32 = _e; }; 2595 { auto _e = u32(); _o->u32 = _e; }; 2596 { auto _e = i64(); _o->i64 = _e; }; 2597 { auto _e = u64(); _o->u64 = _e; }; 2598 { auto _e = f32(); _o->f32 = _e; }; 2599 { auto _e = f64(); _o->f64 = _e; }; 2600 { auto _e = v8(); if (_e) { _o->v8.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->v8[_i] = _e->Get(_i); } } }; 2601 { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } }; 2602 } 2603 2604 inline flatbuffers::Offset<TypeAliases> TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2605 return CreateTypeAliases(_fbb, _o, _rehasher); 2606 } 2607 2608 inline flatbuffers::Offset<TypeAliases> CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2609 (void)_rehasher; 2610 (void)_o; 2611 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2612 auto _i8 = _o->i8; 2613 auto _u8 = _o->u8; 2614 auto _i16 = _o->i16; 2615 auto _u16 = _o->u16; 2616 auto _i32 = _o->i32; 2617 auto _u32 = _o->u32; 2618 auto _i64 = _o->i64; 2619 auto _u64 = _o->u64; 2620 auto _f32 = _o->f32; 2621 auto _f64 = _o->f64; 2622 auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0; 2623 auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0; 2624 return MyGame::Example::CreateTypeAliases( 2625 _fbb, 2626 _i8, 2627 _u8, 2628 _i16, 2629 _u16, 2630 _i32, 2631 _u32, 2632 _i64, 2633 _u64, 2634 _f32, 2635 _f64, 2636 _v8, 2637 _vf64); 2638 } 2639 2640 inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { 2641 switch (type) { 2642 case Any_NONE: { 2643 return true; 2644 } 2645 case Any_Monster: { 2646 auto ptr = reinterpret_cast<const Monster *>(obj); 2647 return verifier.VerifyTable(ptr); 2648 } 2649 case Any_TestSimpleTableWithEnum: { 2650 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 2651 return verifier.VerifyTable(ptr); 2652 } 2653 case Any_MyGame_Example2_Monster: { 2654 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 2655 return verifier.VerifyTable(ptr); 2656 } 2657 default: return false; 2658 } 2659 } 2660 2661 inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 2662 if (!values || !types) return !values && !types; 2663 if (values->size() != types->size()) return false; 2664 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 2665 if (!VerifyAny( 2666 verifier, values->Get(i), types->GetEnum<Any>(i))) { 2667 return false; 2668 } 2669 } 2670 return true; 2671 } 2672 2673 inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { 2674 switch (type) { 2675 case Any_Monster: { 2676 auto ptr = reinterpret_cast<const Monster *>(obj); 2677 return ptr->UnPack(resolver); 2678 } 2679 case Any_TestSimpleTableWithEnum: { 2680 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 2681 return ptr->UnPack(resolver); 2682 } 2683 case Any_MyGame_Example2_Monster: { 2684 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 2685 return ptr->UnPack(resolver); 2686 } 2687 default: return nullptr; 2688 } 2689 } 2690 2691 inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 2692 switch (type) { 2693 case Any_Monster: { 2694 auto ptr = reinterpret_cast<const MonsterT *>(value); 2695 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2696 } 2697 case Any_TestSimpleTableWithEnum: { 2698 auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value); 2699 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); 2700 } 2701 case Any_MyGame_Example2_Monster: { 2702 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value); 2703 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2704 } 2705 default: return 0; 2706 } 2707 } 2708 2709 inline AnyUnion::AnyUnion(const AnyUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { 2710 switch (type) { 2711 case Any_Monster: { 2712 FLATBUFFERS_ASSERT(false); // MonsterT not copyable. 2713 break; 2714 } 2715 case Any_TestSimpleTableWithEnum: { 2716 value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value)); 2717 break; 2718 } 2719 case Any_MyGame_Example2_Monster: { 2720 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value)); 2721 break; 2722 } 2723 default: 2724 break; 2725 } 2726 } 2727 2728 inline void AnyUnion::Reset() { 2729 switch (type) { 2730 case Any_Monster: { 2731 auto ptr = reinterpret_cast<MonsterT *>(value); 2732 delete ptr; 2733 break; 2734 } 2735 case Any_TestSimpleTableWithEnum: { 2736 auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value); 2737 delete ptr; 2738 break; 2739 } 2740 case Any_MyGame_Example2_Monster: { 2741 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value); 2742 delete ptr; 2743 break; 2744 } 2745 default: break; 2746 } 2747 value = nullptr; 2748 type = Any_NONE; 2749 } 2750 2751 inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) { 2752 switch (type) { 2753 case AnyUniqueAliases_NONE: { 2754 return true; 2755 } 2756 case AnyUniqueAliases_M: { 2757 auto ptr = reinterpret_cast<const Monster *>(obj); 2758 return verifier.VerifyTable(ptr); 2759 } 2760 case AnyUniqueAliases_T: { 2761 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 2762 return verifier.VerifyTable(ptr); 2763 } 2764 case AnyUniqueAliases_M2: { 2765 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 2766 return verifier.VerifyTable(ptr); 2767 } 2768 default: return false; 2769 } 2770 } 2771 2772 inline bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 2773 if (!values || !types) return !values && !types; 2774 if (values->size() != types->size()) return false; 2775 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 2776 if (!VerifyAnyUniqueAliases( 2777 verifier, values->Get(i), types->GetEnum<AnyUniqueAliases>(i))) { 2778 return false; 2779 } 2780 } 2781 return true; 2782 } 2783 2784 inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver) { 2785 switch (type) { 2786 case AnyUniqueAliases_M: { 2787 auto ptr = reinterpret_cast<const Monster *>(obj); 2788 return ptr->UnPack(resolver); 2789 } 2790 case AnyUniqueAliases_T: { 2791 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 2792 return ptr->UnPack(resolver); 2793 } 2794 case AnyUniqueAliases_M2: { 2795 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 2796 return ptr->UnPack(resolver); 2797 } 2798 default: return nullptr; 2799 } 2800 } 2801 2802 inline flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 2803 switch (type) { 2804 case AnyUniqueAliases_M: { 2805 auto ptr = reinterpret_cast<const MonsterT *>(value); 2806 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2807 } 2808 case AnyUniqueAliases_T: { 2809 auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value); 2810 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); 2811 } 2812 case AnyUniqueAliases_M2: { 2813 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value); 2814 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2815 } 2816 default: return 0; 2817 } 2818 } 2819 2820 inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { 2821 switch (type) { 2822 case AnyUniqueAliases_M: { 2823 FLATBUFFERS_ASSERT(false); // MonsterT not copyable. 2824 break; 2825 } 2826 case AnyUniqueAliases_T: { 2827 value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value)); 2828 break; 2829 } 2830 case AnyUniqueAliases_M2: { 2831 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value)); 2832 break; 2833 } 2834 default: 2835 break; 2836 } 2837 } 2838 2839 inline void AnyUniqueAliasesUnion::Reset() { 2840 switch (type) { 2841 case AnyUniqueAliases_M: { 2842 auto ptr = reinterpret_cast<MonsterT *>(value); 2843 delete ptr; 2844 break; 2845 } 2846 case AnyUniqueAliases_T: { 2847 auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value); 2848 delete ptr; 2849 break; 2850 } 2851 case AnyUniqueAliases_M2: { 2852 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value); 2853 delete ptr; 2854 break; 2855 } 2856 default: break; 2857 } 2858 value = nullptr; 2859 type = AnyUniqueAliases_NONE; 2860 } 2861 2862 inline bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) { 2863 switch (type) { 2864 case AnyAmbiguousAliases_NONE: { 2865 return true; 2866 } 2867 case AnyAmbiguousAliases_M1: { 2868 auto ptr = reinterpret_cast<const Monster *>(obj); 2869 return verifier.VerifyTable(ptr); 2870 } 2871 case AnyAmbiguousAliases_M2: { 2872 auto ptr = reinterpret_cast<const Monster *>(obj); 2873 return verifier.VerifyTable(ptr); 2874 } 2875 case AnyAmbiguousAliases_M3: { 2876 auto ptr = reinterpret_cast<const Monster *>(obj); 2877 return verifier.VerifyTable(ptr); 2878 } 2879 default: return false; 2880 } 2881 } 2882 2883 inline bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 2884 if (!values || !types) return !values && !types; 2885 if (values->size() != types->size()) return false; 2886 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 2887 if (!VerifyAnyAmbiguousAliases( 2888 verifier, values->Get(i), types->GetEnum<AnyAmbiguousAliases>(i))) { 2889 return false; 2890 } 2891 } 2892 return true; 2893 } 2894 2895 inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver) { 2896 switch (type) { 2897 case AnyAmbiguousAliases_M1: { 2898 auto ptr = reinterpret_cast<const Monster *>(obj); 2899 return ptr->UnPack(resolver); 2900 } 2901 case AnyAmbiguousAliases_M2: { 2902 auto ptr = reinterpret_cast<const Monster *>(obj); 2903 return ptr->UnPack(resolver); 2904 } 2905 case AnyAmbiguousAliases_M3: { 2906 auto ptr = reinterpret_cast<const Monster *>(obj); 2907 return ptr->UnPack(resolver); 2908 } 2909 default: return nullptr; 2910 } 2911 } 2912 2913 inline flatbuffers::Offset<void> AnyAmbiguousAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 2914 switch (type) { 2915 case AnyAmbiguousAliases_M1: { 2916 auto ptr = reinterpret_cast<const MonsterT *>(value); 2917 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2918 } 2919 case AnyAmbiguousAliases_M2: { 2920 auto ptr = reinterpret_cast<const MonsterT *>(value); 2921 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2922 } 2923 case AnyAmbiguousAliases_M3: { 2924 auto ptr = reinterpret_cast<const MonsterT *>(value); 2925 return CreateMonster(_fbb, ptr, _rehasher).Union(); 2926 } 2927 default: return 0; 2928 } 2929 } 2930 2931 inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { 2932 switch (type) { 2933 case AnyAmbiguousAliases_M1: { 2934 FLATBUFFERS_ASSERT(false); // MonsterT not copyable. 2935 break; 2936 } 2937 case AnyAmbiguousAliases_M2: { 2938 FLATBUFFERS_ASSERT(false); // MonsterT not copyable. 2939 break; 2940 } 2941 case AnyAmbiguousAliases_M3: { 2942 FLATBUFFERS_ASSERT(false); // MonsterT not copyable. 2943 break; 2944 } 2945 default: 2946 break; 2947 } 2948 } 2949 2950 inline void AnyAmbiguousAliasesUnion::Reset() { 2951 switch (type) { 2952 case AnyAmbiguousAliases_M1: { 2953 auto ptr = reinterpret_cast<MonsterT *>(value); 2954 delete ptr; 2955 break; 2956 } 2957 case AnyAmbiguousAliases_M2: { 2958 auto ptr = reinterpret_cast<MonsterT *>(value); 2959 delete ptr; 2960 break; 2961 } 2962 case AnyAmbiguousAliases_M3: { 2963 auto ptr = reinterpret_cast<MonsterT *>(value); 2964 delete ptr; 2965 break; 2966 } 2967 default: break; 2968 } 2969 value = nullptr; 2970 type = AnyAmbiguousAliases_NONE; 2971 } 2972 2973 inline const flatbuffers::TypeTable *ColorTypeTable() { 2974 static const flatbuffers::TypeCode type_codes[] = { 2975 { flatbuffers::ET_CHAR, 0, 0 }, 2976 { flatbuffers::ET_CHAR, 0, 0 }, 2977 { flatbuffers::ET_CHAR, 0, 0 } 2978 }; 2979 static const flatbuffers::TypeFunction type_refs[] = { 2980 ColorTypeTable 2981 }; 2982 static const int64_t values[] = { 1, 2, 8 }; 2983 static const char * const names[] = { 2984 "Red", 2985 "Green", 2986 "Blue" 2987 }; 2988 static const flatbuffers::TypeTable tt = { 2989 flatbuffers::ST_ENUM, 3, type_codes, type_refs, values, names 2990 }; 2991 return &tt; 2992 } 2993 2994 inline const flatbuffers::TypeTable *AnyTypeTable() { 2995 static const flatbuffers::TypeCode type_codes[] = { 2996 { flatbuffers::ET_SEQUENCE, 0, -1 }, 2997 { flatbuffers::ET_SEQUENCE, 0, 0 }, 2998 { flatbuffers::ET_SEQUENCE, 0, 1 }, 2999 { flatbuffers::ET_SEQUENCE, 0, 2 } 3000 }; 3001 static const flatbuffers::TypeFunction type_refs[] = { 3002 MonsterTypeTable, 3003 TestSimpleTableWithEnumTypeTable, 3004 MyGame::Example2::MonsterTypeTable 3005 }; 3006 static const char * const names[] = { 3007 "NONE", 3008 "Monster", 3009 "TestSimpleTableWithEnum", 3010 "MyGame_Example2_Monster" 3011 }; 3012 static const flatbuffers::TypeTable tt = { 3013 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names 3014 }; 3015 return &tt; 3016 } 3017 3018 inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() { 3019 static const flatbuffers::TypeCode type_codes[] = { 3020 { flatbuffers::ET_SEQUENCE, 0, -1 }, 3021 { flatbuffers::ET_SEQUENCE, 0, 0 }, 3022 { flatbuffers::ET_SEQUENCE, 0, 1 }, 3023 { flatbuffers::ET_SEQUENCE, 0, 2 } 3024 }; 3025 static const flatbuffers::TypeFunction type_refs[] = { 3026 MonsterTypeTable, 3027 TestSimpleTableWithEnumTypeTable, 3028 MyGame::Example2::MonsterTypeTable 3029 }; 3030 static const char * const names[] = { 3031 "NONE", 3032 "M", 3033 "T", 3034 "M2" 3035 }; 3036 static const flatbuffers::TypeTable tt = { 3037 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names 3038 }; 3039 return &tt; 3040 } 3041 3042 inline const flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() { 3043 static const flatbuffers::TypeCode type_codes[] = { 3044 { flatbuffers::ET_SEQUENCE, 0, -1 }, 3045 { flatbuffers::ET_SEQUENCE, 0, 0 }, 3046 { flatbuffers::ET_SEQUENCE, 0, 0 }, 3047 { flatbuffers::ET_SEQUENCE, 0, 0 } 3048 }; 3049 static const flatbuffers::TypeFunction type_refs[] = { 3050 MonsterTypeTable 3051 }; 3052 static const char * const names[] = { 3053 "NONE", 3054 "M1", 3055 "M2", 3056 "M3" 3057 }; 3058 static const flatbuffers::TypeTable tt = { 3059 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names 3060 }; 3061 return &tt; 3062 } 3063 3064 } // namespace Example 3065 3066 inline const flatbuffers::TypeTable *InParentNamespaceTypeTable() { 3067 static const flatbuffers::TypeTable tt = { 3068 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr 3069 }; 3070 return &tt; 3071 } 3072 3073 namespace Example2 { 3074 3075 inline const flatbuffers::TypeTable *MonsterTypeTable() { 3076 static const flatbuffers::TypeTable tt = { 3077 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr 3078 }; 3079 return &tt; 3080 } 3081 3082 } // namespace Example2 3083 3084 namespace Example { 3085 3086 inline const flatbuffers::TypeTable *TestTypeTable() { 3087 static const flatbuffers::TypeCode type_codes[] = { 3088 { flatbuffers::ET_SHORT, 0, -1 }, 3089 { flatbuffers::ET_CHAR, 0, -1 } 3090 }; 3091 static const int64_t values[] = { 0, 2, 4 }; 3092 static const char * const names[] = { 3093 "a", 3094 "b" 3095 }; 3096 static const flatbuffers::TypeTable tt = { 3097 flatbuffers::ST_STRUCT, 2, type_codes, nullptr, values, names 3098 }; 3099 return &tt; 3100 } 3101 3102 inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() { 3103 static const flatbuffers::TypeCode type_codes[] = { 3104 { flatbuffers::ET_CHAR, 0, 0 } 3105 }; 3106 static const flatbuffers::TypeFunction type_refs[] = { 3107 ColorTypeTable 3108 }; 3109 static const char * const names[] = { 3110 "color" 3111 }; 3112 static const flatbuffers::TypeTable tt = { 3113 flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, names 3114 }; 3115 return &tt; 3116 } 3117 3118 inline const flatbuffers::TypeTable *Vec3TypeTable() { 3119 static const flatbuffers::TypeCode type_codes[] = { 3120 { flatbuffers::ET_FLOAT, 0, -1 }, 3121 { flatbuffers::ET_FLOAT, 0, -1 }, 3122 { flatbuffers::ET_FLOAT, 0, -1 }, 3123 { flatbuffers::ET_DOUBLE, 0, -1 }, 3124 { flatbuffers::ET_CHAR, 0, 0 }, 3125 { flatbuffers::ET_SEQUENCE, 0, 1 } 3126 }; 3127 static const flatbuffers::TypeFunction type_refs[] = { 3128 ColorTypeTable, 3129 TestTypeTable 3130 }; 3131 static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 }; 3132 static const char * const names[] = { 3133 "x", 3134 "y", 3135 "z", 3136 "test1", 3137 "test2", 3138 "test3" 3139 }; 3140 static const flatbuffers::TypeTable tt = { 3141 flatbuffers::ST_STRUCT, 6, type_codes, type_refs, values, names 3142 }; 3143 return &tt; 3144 } 3145 3146 inline const flatbuffers::TypeTable *AbilityTypeTable() { 3147 static const flatbuffers::TypeCode type_codes[] = { 3148 { flatbuffers::ET_UINT, 0, -1 }, 3149 { flatbuffers::ET_UINT, 0, -1 } 3150 }; 3151 static const int64_t values[] = { 0, 4, 8 }; 3152 static const char * const names[] = { 3153 "id", 3154 "distance" 3155 }; 3156 static const flatbuffers::TypeTable tt = { 3157 flatbuffers::ST_STRUCT, 2, type_codes, nullptr, values, names 3158 }; 3159 return &tt; 3160 } 3161 3162 inline const flatbuffers::TypeTable *StatTypeTable() { 3163 static const flatbuffers::TypeCode type_codes[] = { 3164 { flatbuffers::ET_STRING, 0, -1 }, 3165 { flatbuffers::ET_LONG, 0, -1 }, 3166 { flatbuffers::ET_USHORT, 0, -1 } 3167 }; 3168 static const char * const names[] = { 3169 "id", 3170 "val", 3171 "count" 3172 }; 3173 static const flatbuffers::TypeTable tt = { 3174 flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, names 3175 }; 3176 return &tt; 3177 } 3178 3179 inline const flatbuffers::TypeTable *ReferrableTypeTable() { 3180 static const flatbuffers::TypeCode type_codes[] = { 3181 { flatbuffers::ET_ULONG, 0, -1 } 3182 }; 3183 static const char * const names[] = { 3184 "id" 3185 }; 3186 static const flatbuffers::TypeTable tt = { 3187 flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, names 3188 }; 3189 return &tt; 3190 } 3191 3192 inline const flatbuffers::TypeTable *MonsterTypeTable() { 3193 static const flatbuffers::TypeCode type_codes[] = { 3194 { flatbuffers::ET_SEQUENCE, 0, 0 }, 3195 { flatbuffers::ET_SHORT, 0, -1 }, 3196 { flatbuffers::ET_SHORT, 0, -1 }, 3197 { flatbuffers::ET_STRING, 0, -1 }, 3198 { flatbuffers::ET_BOOL, 0, -1 }, 3199 { flatbuffers::ET_UCHAR, 1, -1 }, 3200 { flatbuffers::ET_CHAR, 0, 1 }, 3201 { flatbuffers::ET_UTYPE, 0, 2 }, 3202 { flatbuffers::ET_SEQUENCE, 0, 2 }, 3203 { flatbuffers::ET_SEQUENCE, 1, 3 }, 3204 { flatbuffers::ET_STRING, 1, -1 }, 3205 { flatbuffers::ET_SEQUENCE, 1, 4 }, 3206 { flatbuffers::ET_SEQUENCE, 0, 4 }, 3207 { flatbuffers::ET_UCHAR, 1, -1 }, 3208 { flatbuffers::ET_SEQUENCE, 0, 5 }, 3209 { flatbuffers::ET_BOOL, 0, -1 }, 3210 { flatbuffers::ET_INT, 0, -1 }, 3211 { flatbuffers::ET_UINT, 0, -1 }, 3212 { flatbuffers::ET_LONG, 0, -1 }, 3213 { flatbuffers::ET_ULONG, 0, -1 }, 3214 { flatbuffers::ET_INT, 0, -1 }, 3215 { flatbuffers::ET_UINT, 0, -1 }, 3216 { flatbuffers::ET_LONG, 0, -1 }, 3217 { flatbuffers::ET_ULONG, 0, -1 }, 3218 { flatbuffers::ET_BOOL, 1, -1 }, 3219 { flatbuffers::ET_FLOAT, 0, -1 }, 3220 { flatbuffers::ET_FLOAT, 0, -1 }, 3221 { flatbuffers::ET_FLOAT, 0, -1 }, 3222 { flatbuffers::ET_STRING, 1, -1 }, 3223 { flatbuffers::ET_SEQUENCE, 1, 6 }, 3224 { flatbuffers::ET_UCHAR, 1, -1 }, 3225 { flatbuffers::ET_SEQUENCE, 1, 3 }, 3226 { flatbuffers::ET_LONG, 1, -1 }, 3227 { flatbuffers::ET_DOUBLE, 1, -1 }, 3228 { flatbuffers::ET_SEQUENCE, 0, 7 }, 3229 { flatbuffers::ET_SEQUENCE, 1, 8 }, 3230 { flatbuffers::ET_ULONG, 0, -1 }, 3231 { flatbuffers::ET_ULONG, 1, -1 }, 3232 { flatbuffers::ET_SEQUENCE, 1, 8 }, 3233 { flatbuffers::ET_ULONG, 0, -1 }, 3234 { flatbuffers::ET_ULONG, 1, -1 }, 3235 { flatbuffers::ET_ULONG, 0, -1 }, 3236 { flatbuffers::ET_ULONG, 1, -1 }, 3237 { flatbuffers::ET_UTYPE, 0, 9 }, 3238 { flatbuffers::ET_SEQUENCE, 0, 9 }, 3239 { flatbuffers::ET_UTYPE, 0, 10 }, 3240 { flatbuffers::ET_SEQUENCE, 0, 10 }, 3241 { flatbuffers::ET_CHAR, 1, 1 } 3242 }; 3243 static const flatbuffers::TypeFunction type_refs[] = { 3244 Vec3TypeTable, 3245 ColorTypeTable, 3246 AnyTypeTable, 3247 TestTypeTable, 3248 MonsterTypeTable, 3249 StatTypeTable, 3250 AbilityTypeTable, 3251 MyGame::InParentNamespaceTypeTable, 3252 ReferrableTypeTable, 3253 AnyUniqueAliasesTypeTable, 3254 AnyAmbiguousAliasesTypeTable 3255 }; 3256 static const char * const names[] = { 3257 "pos", 3258 "mana", 3259 "hp", 3260 "name", 3261 "friendly", 3262 "inventory", 3263 "color", 3264 "test_type", 3265 "test", 3266 "test4", 3267 "testarrayofstring", 3268 "testarrayoftables", 3269 "enemy", 3270 "testnestedflatbuffer", 3271 "testempty", 3272 "testbool", 3273 "testhashs32_fnv1", 3274 "testhashu32_fnv1", 3275 "testhashs64_fnv1", 3276 "testhashu64_fnv1", 3277 "testhashs32_fnv1a", 3278 "testhashu32_fnv1a", 3279 "testhashs64_fnv1a", 3280 "testhashu64_fnv1a", 3281 "testarrayofbools", 3282 "testf", 3283 "testf2", 3284 "testf3", 3285 "testarrayofstring2", 3286 "testarrayofsortedstruct", 3287 "flex", 3288 "test5", 3289 "vector_of_longs", 3290 "vector_of_doubles", 3291 "parent_namespace_test", 3292 "vector_of_referrables", 3293 "single_weak_reference", 3294 "vector_of_weak_references", 3295 "vector_of_strong_referrables", 3296 "co_owning_reference", 3297 "vector_of_co_owning_references", 3298 "non_owning_reference", 3299 "vector_of_non_owning_references", 3300 "any_unique_type", 3301 "any_unique", 3302 "any_ambiguous_type", 3303 "any_ambiguous", 3304 "vector_of_enums" 3305 }; 3306 static const flatbuffers::TypeTable tt = { 3307 flatbuffers::ST_TABLE, 48, type_codes, type_refs, nullptr, names 3308 }; 3309 return &tt; 3310 } 3311 3312 inline const flatbuffers::TypeTable *TypeAliasesTypeTable() { 3313 static const flatbuffers::TypeCode type_codes[] = { 3314 { flatbuffers::ET_CHAR, 0, -1 }, 3315 { flatbuffers::ET_UCHAR, 0, -1 }, 3316 { flatbuffers::ET_SHORT, 0, -1 }, 3317 { flatbuffers::ET_USHORT, 0, -1 }, 3318 { flatbuffers::ET_INT, 0, -1 }, 3319 { flatbuffers::ET_UINT, 0, -1 }, 3320 { flatbuffers::ET_LONG, 0, -1 }, 3321 { flatbuffers::ET_ULONG, 0, -1 }, 3322 { flatbuffers::ET_FLOAT, 0, -1 }, 3323 { flatbuffers::ET_DOUBLE, 0, -1 }, 3324 { flatbuffers::ET_CHAR, 1, -1 }, 3325 { flatbuffers::ET_DOUBLE, 1, -1 } 3326 }; 3327 static const char * const names[] = { 3328 "i8", 3329 "u8", 3330 "i16", 3331 "u16", 3332 "i32", 3333 "u32", 3334 "i64", 3335 "u64", 3336 "f32", 3337 "f64", 3338 "v8", 3339 "vf64" 3340 }; 3341 static const flatbuffers::TypeTable tt = { 3342 flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, names 3343 }; 3344 return &tt; 3345 } 3346 3347 inline const MyGame::Example::Monster *GetMonster(const void *buf) { 3348 return flatbuffers::GetRoot<MyGame::Example::Monster>(buf); 3349 } 3350 3351 inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) { 3352 return flatbuffers::GetSizePrefixedRoot<MyGame::Example::Monster>(buf); 3353 } 3354 3355 inline Monster *GetMutableMonster(void *buf) { 3356 return flatbuffers::GetMutableRoot<Monster>(buf); 3357 } 3358 3359 inline const char *MonsterIdentifier() { 3360 return "MONS"; 3361 } 3362 3363 inline bool MonsterBufferHasIdentifier(const void *buf) { 3364 return flatbuffers::BufferHasIdentifier( 3365 buf, MonsterIdentifier()); 3366 } 3367 3368 inline bool VerifyMonsterBuffer( 3369 flatbuffers::Verifier &verifier) { 3370 return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier()); 3371 } 3372 3373 inline bool VerifySizePrefixedMonsterBuffer( 3374 flatbuffers::Verifier &verifier) { 3375 return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier()); 3376 } 3377 3378 inline const char *MonsterExtension() { 3379 return "mon"; 3380 } 3381 3382 inline void FinishMonsterBuffer( 3383 flatbuffers::FlatBufferBuilder &fbb, 3384 flatbuffers::Offset<MyGame::Example::Monster> root) { 3385 fbb.Finish(root, MonsterIdentifier()); 3386 } 3387 3388 inline void FinishSizePrefixedMonsterBuffer( 3389 flatbuffers::FlatBufferBuilder &fbb, 3390 flatbuffers::Offset<MyGame::Example::Monster> root) { 3391 fbb.FinishSizePrefixed(root, MonsterIdentifier()); 3392 } 3393 3394 inline flatbuffers::unique_ptr<MonsterT> UnPackMonster( 3395 const void *buf, 3396 const flatbuffers::resolver_function_t *res = nullptr) { 3397 return flatbuffers::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res)); 3398 } 3399 3400 } // namespace Example 3401 } // namespace MyGame 3402 3403 #endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ 3404
