tests/monster_test_generated.h

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