...

Text file src/github.com/google/flatbuffers/tests/cpp17/generated_cpp17/monster_test_generated.h

Documentation: github.com/google/flatbuffers/tests/cpp17/generated_cpp17

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

View as plain text