...

Text file src/github.com/google/flatbuffers/tests/cpp17/generated_cpp17/union_vector_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_UNIONVECTOR_H_
     5#define FLATBUFFERS_GENERATED_UNIONVECTOR_H_
     6
     7#include "flatbuffers/flatbuffers.h"
     8
     9// Ensure the included flatbuffers.h is the same version as when this file was
    10// generated, otherwise it may not be compatible.
    11static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
    12              FLATBUFFERS_VERSION_MINOR == 5 &&
    13              FLATBUFFERS_VERSION_REVISION == 26,
    14             "Non-compatible flatbuffers version included");
    15
    16struct Attacker;
    17struct AttackerBuilder;
    18struct AttackerT;
    19
    20struct Rapunzel;
    21
    22struct BookReader;
    23
    24struct FallingTub;
    25
    26struct HandFan;
    27struct HandFanBuilder;
    28struct HandFanT;
    29
    30struct Movie;
    31struct MovieBuilder;
    32struct MovieT;
    33
    34inline const ::flatbuffers::TypeTable *AttackerTypeTable();
    35
    36inline const ::flatbuffers::TypeTable *RapunzelTypeTable();
    37
    38inline const ::flatbuffers::TypeTable *BookReaderTypeTable();
    39
    40inline const ::flatbuffers::TypeTable *FallingTubTypeTable();
    41
    42inline const ::flatbuffers::TypeTable *HandFanTypeTable();
    43
    44inline const ::flatbuffers::TypeTable *MovieTypeTable();
    45
    46enum class Character : uint8_t {
    47  NONE = 0,
    48  MuLan = 1,
    49  Rapunzel = 2,
    50  Belle = 3,
    51  BookFan = 4,
    52  Other = 5,
    53  Unused = 6,
    54  MIN = NONE,
    55  MAX = Unused
    56};
    57
    58inline const Character (&EnumValuesCharacter())[7] {
    59  static const Character values[] = {
    60    Character::NONE,
    61    Character::MuLan,
    62    Character::Rapunzel,
    63    Character::Belle,
    64    Character::BookFan,
    65    Character::Other,
    66    Character::Unused
    67  };
    68  return values;
    69}
    70
    71inline const char * const *EnumNamesCharacter() {
    72  static const char * const names[8] = {
    73    "NONE",
    74    "MuLan",
    75    "Rapunzel",
    76    "Belle",
    77    "BookFan",
    78    "Other",
    79    "Unused",
    80    nullptr
    81  };
    82  return names;
    83}
    84
    85inline const char *EnumNameCharacter(Character e) {
    86  if (::flatbuffers::IsOutRange(e, Character::NONE, Character::Unused)) return "";
    87  const size_t index = static_cast<size_t>(e);
    88  return EnumNamesCharacter()[index];
    89}
    90
    91struct CharacterUnion {
    92  Character type;
    93  void *value;
    94
    95  CharacterUnion() : type(Character::NONE), value(nullptr) {}
    96  CharacterUnion(CharacterUnion&& u) FLATBUFFERS_NOEXCEPT :
    97    type(Character::NONE), value(nullptr)
    98    { std::swap(type, u.type); std::swap(value, u.value); }
    99  CharacterUnion(const CharacterUnion &);
   100  CharacterUnion &operator=(const CharacterUnion &u)
   101    { CharacterUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
   102  CharacterUnion &operator=(CharacterUnion &&u) FLATBUFFERS_NOEXCEPT
   103    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
   104  ~CharacterUnion() { Reset(); }
   105
   106  void Reset();
   107
   108  static void *UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver);
   109  ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
   110
   111  AttackerT *AsMuLan() {
   112    return type == Character::MuLan ?
   113      reinterpret_cast<AttackerT *>(value) : nullptr;
   114  }
   115  const AttackerT *AsMuLan() const {
   116    return type == Character::MuLan ?
   117      reinterpret_cast<const AttackerT *>(value) : nullptr;
   118  }
   119  Rapunzel *AsRapunzel() {
   120    return type == Character::Rapunzel ?
   121      reinterpret_cast<Rapunzel *>(value) : nullptr;
   122  }
   123  const Rapunzel *AsRapunzel() const {
   124    return type == Character::Rapunzel ?
   125      reinterpret_cast<const Rapunzel *>(value) : nullptr;
   126  }
   127  BookReader *AsBelle() {
   128    return type == Character::Belle ?
   129      reinterpret_cast<BookReader *>(value) : nullptr;
   130  }
   131  const BookReader *AsBelle() const {
   132    return type == Character::Belle ?
   133      reinterpret_cast<const BookReader *>(value) : nullptr;
   134  }
   135  BookReader *AsBookFan() {
   136    return type == Character::BookFan ?
   137      reinterpret_cast<BookReader *>(value) : nullptr;
   138  }
   139  const BookReader *AsBookFan() const {
   140    return type == Character::BookFan ?
   141      reinterpret_cast<const BookReader *>(value) : nullptr;
   142  }
   143  std::string *AsOther() {
   144    return type == Character::Other ?
   145      reinterpret_cast<std::string *>(value) : nullptr;
   146  }
   147  const std::string *AsOther() const {
   148    return type == Character::Other ?
   149      reinterpret_cast<const std::string *>(value) : nullptr;
   150  }
   151  std::string *AsUnused() {
   152    return type == Character::Unused ?
   153      reinterpret_cast<std::string *>(value) : nullptr;
   154  }
   155  const std::string *AsUnused() const {
   156    return type == Character::Unused ?
   157      reinterpret_cast<const std::string *>(value) : nullptr;
   158  }
   159};
   160
   161bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
   162bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
   163
   164enum class Gadget : uint8_t {
   165  NONE = 0,
   166  FallingTub = 1,
   167  HandFan = 2,
   168  MIN = NONE,
   169  MAX = HandFan
   170};
   171
   172inline const Gadget (&EnumValuesGadget())[3] {
   173  static const Gadget values[] = {
   174    Gadget::NONE,
   175    Gadget::FallingTub,
   176    Gadget::HandFan
   177  };
   178  return values;
   179}
   180
   181inline const char * const *EnumNamesGadget() {
   182  static const char * const names[4] = {
   183    "NONE",
   184    "FallingTub",
   185    "HandFan",
   186    nullptr
   187  };
   188  return names;
   189}
   190
   191inline const char *EnumNameGadget(Gadget e) {
   192  if (::flatbuffers::IsOutRange(e, Gadget::NONE, Gadget::HandFan)) return "";
   193  const size_t index = static_cast<size_t>(e);
   194  return EnumNamesGadget()[index];
   195}
   196
   197template<typename T> struct GadgetTraits {
   198  static const Gadget enum_value = Gadget::NONE;
   199};
   200
   201template<> struct GadgetTraits<FallingTub> {
   202  static const Gadget enum_value = Gadget::FallingTub;
   203};
   204
   205template<> struct GadgetTraits<HandFan> {
   206  static const Gadget enum_value = Gadget::HandFan;
   207};
   208
   209template<typename T> struct GadgetUnionTraits {
   210  static const Gadget enum_value = Gadget::NONE;
   211};
   212
   213template<> struct GadgetUnionTraits<FallingTub> {
   214  static const Gadget enum_value = Gadget::FallingTub;
   215};
   216
   217template<> struct GadgetUnionTraits<HandFanT> {
   218  static const Gadget enum_value = Gadget::HandFan;
   219};
   220
   221struct GadgetUnion {
   222  Gadget type;
   223  void *value;
   224
   225  GadgetUnion() : type(Gadget::NONE), value(nullptr) {}
   226  GadgetUnion(GadgetUnion&& u) FLATBUFFERS_NOEXCEPT :
   227    type(Gadget::NONE), value(nullptr)
   228    { std::swap(type, u.type); std::swap(value, u.value); }
   229  GadgetUnion(const GadgetUnion &);
   230  GadgetUnion &operator=(const GadgetUnion &u)
   231    { GadgetUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
   232  GadgetUnion &operator=(GadgetUnion &&u) FLATBUFFERS_NOEXCEPT
   233    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
   234  ~GadgetUnion() { Reset(); }
   235
   236  void Reset();
   237
   238  template <typename T>
   239  void Set(T&& val) {
   240    typedef typename std::remove_reference<T>::type RT;
   241    Reset();
   242    type = GadgetUnionTraits<RT>::enum_value;
   243    if (type != Gadget::NONE) {
   244      value = new RT(std::forward<T>(val));
   245    }
   246  }
   247
   248  static void *UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver);
   249  ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
   250
   251  FallingTub *AsFallingTub() {
   252    return type == Gadget::FallingTub ?
   253      reinterpret_cast<FallingTub *>(value) : nullptr;
   254  }
   255  const FallingTub *AsFallingTub() const {
   256    return type == Gadget::FallingTub ?
   257      reinterpret_cast<const FallingTub *>(value) : nullptr;
   258  }
   259  HandFanT *AsHandFan() {
   260    return type == Gadget::HandFan ?
   261      reinterpret_cast<HandFanT *>(value) : nullptr;
   262  }
   263  const HandFanT *AsHandFan() const {
   264    return type == Gadget::HandFan ?
   265      reinterpret_cast<const HandFanT *>(value) : nullptr;
   266  }
   267};
   268
   269bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
   270bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
   271
   272FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
   273 private:
   274  int32_t hair_length_;
   275
   276 public:
   277  struct Traits;
   278  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   279    return RapunzelTypeTable();
   280  }
   281  Rapunzel()
   282      : hair_length_(0) {
   283  }
   284  Rapunzel(int32_t _hair_length)
   285      : hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
   286  }
   287  int32_t hair_length() const {
   288    return ::flatbuffers::EndianScalar(hair_length_);
   289  }
   290  void mutate_hair_length(int32_t _hair_length) {
   291    ::flatbuffers::WriteScalar(&hair_length_, _hair_length);
   292  }
   293  template<size_t Index>
   294  auto get_field() const {
   295         if constexpr (Index == 0) return hair_length();
   296    else static_assert(Index != Index, "Invalid Field Index");
   297  }
   298};
   299FLATBUFFERS_STRUCT_END(Rapunzel, 4);
   300
   301struct Rapunzel::Traits {
   302  using type = Rapunzel;
   303  static constexpr auto name = "Rapunzel";
   304  static constexpr auto fully_qualified_name = "Rapunzel";
   305  static constexpr size_t fields_number = 1;
   306  static constexpr std::array<const char *, fields_number> field_names = {
   307    "hair_length"
   308  };
   309  template<size_t Index>
   310  using FieldType = decltype(std::declval<type>().get_field<Index>());
   311};
   312
   313FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
   314 private:
   315  int32_t books_read_;
   316
   317 public:
   318  struct Traits;
   319  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   320    return BookReaderTypeTable();
   321  }
   322  BookReader()
   323      : books_read_(0) {
   324  }
   325  BookReader(int32_t _books_read)
   326      : books_read_(::flatbuffers::EndianScalar(_books_read)) {
   327  }
   328  int32_t books_read() const {
   329    return ::flatbuffers::EndianScalar(books_read_);
   330  }
   331  void mutate_books_read(int32_t _books_read) {
   332    ::flatbuffers::WriteScalar(&books_read_, _books_read);
   333  }
   334  template<size_t Index>
   335  auto get_field() const {
   336         if constexpr (Index == 0) return books_read();
   337    else static_assert(Index != Index, "Invalid Field Index");
   338  }
   339};
   340FLATBUFFERS_STRUCT_END(BookReader, 4);
   341
   342struct BookReader::Traits {
   343  using type = BookReader;
   344  static constexpr auto name = "BookReader";
   345  static constexpr auto fully_qualified_name = "BookReader";
   346  static constexpr size_t fields_number = 1;
   347  static constexpr std::array<const char *, fields_number> field_names = {
   348    "books_read"
   349  };
   350  template<size_t Index>
   351  using FieldType = decltype(std::declval<type>().get_field<Index>());
   352};
   353
   354FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
   355 private:
   356  int32_t weight_;
   357
   358 public:
   359  struct Traits;
   360  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   361    return FallingTubTypeTable();
   362  }
   363  FallingTub()
   364      : weight_(0) {
   365  }
   366  FallingTub(int32_t _weight)
   367      : weight_(::flatbuffers::EndianScalar(_weight)) {
   368  }
   369  int32_t weight() const {
   370    return ::flatbuffers::EndianScalar(weight_);
   371  }
   372  void mutate_weight(int32_t _weight) {
   373    ::flatbuffers::WriteScalar(&weight_, _weight);
   374  }
   375  template<size_t Index>
   376  auto get_field() const {
   377         if constexpr (Index == 0) return weight();
   378    else static_assert(Index != Index, "Invalid Field Index");
   379  }
   380};
   381FLATBUFFERS_STRUCT_END(FallingTub, 4);
   382
   383struct FallingTub::Traits {
   384  using type = FallingTub;
   385  static constexpr auto name = "FallingTub";
   386  static constexpr auto fully_qualified_name = "FallingTub";
   387  static constexpr size_t fields_number = 1;
   388  static constexpr std::array<const char *, fields_number> field_names = {
   389    "weight"
   390  };
   391  template<size_t Index>
   392  using FieldType = decltype(std::declval<type>().get_field<Index>());
   393};
   394
   395struct AttackerT : public ::flatbuffers::NativeTable {
   396  typedef Attacker TableType;
   397  int32_t sword_attack_damage = 0;
   398};
   399
   400struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   401  typedef AttackerT NativeTableType;
   402  typedef AttackerBuilder Builder;
   403  struct Traits;
   404  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   405    return AttackerTypeTable();
   406  }
   407  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
   408    VT_SWORD_ATTACK_DAMAGE = 4
   409  };
   410  int32_t sword_attack_damage() const {
   411    return GetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, 0);
   412  }
   413  bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) {
   414    return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
   415  }
   416  template<size_t Index>
   417  auto get_field() const {
   418         if constexpr (Index == 0) return sword_attack_damage();
   419    else static_assert(Index != Index, "Invalid Field Index");
   420  }
   421  bool Verify(::flatbuffers::Verifier &verifier) const {
   422    return VerifyTableStart(verifier) &&
   423           VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
   424           verifier.EndTable();
   425  }
   426  AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   427  void UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   428  static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   429};
   430
   431struct AttackerBuilder {
   432  typedef Attacker Table;
   433  ::flatbuffers::FlatBufferBuilder &fbb_;
   434  ::flatbuffers::uoffset_t start_;
   435  void add_sword_attack_damage(int32_t sword_attack_damage) {
   436    fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
   437  }
   438  explicit AttackerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
   439        : fbb_(_fbb) {
   440    start_ = fbb_.StartTable();
   441  }
   442  ::flatbuffers::Offset<Attacker> Finish() {
   443    const auto end = fbb_.EndTable(start_);
   444    auto o = ::flatbuffers::Offset<Attacker>(end);
   445    return o;
   446  }
   447};
   448
   449inline ::flatbuffers::Offset<Attacker> CreateAttacker(
   450    ::flatbuffers::FlatBufferBuilder &_fbb,
   451    int32_t sword_attack_damage = 0) {
   452  AttackerBuilder builder_(_fbb);
   453  builder_.add_sword_attack_damage(sword_attack_damage);
   454  return builder_.Finish();
   455}
   456
   457struct Attacker::Traits {
   458  using type = Attacker;
   459  static auto constexpr Create = CreateAttacker;
   460  static constexpr auto name = "Attacker";
   461  static constexpr auto fully_qualified_name = "Attacker";
   462  static constexpr size_t fields_number = 1;
   463  static constexpr std::array<const char *, fields_number> field_names = {
   464    "sword_attack_damage"
   465  };
   466  template<size_t Index>
   467  using FieldType = decltype(std::declval<type>().get_field<Index>());
   468};
   469
   470::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   471
   472struct HandFanT : public ::flatbuffers::NativeTable {
   473  typedef HandFan TableType;
   474  int32_t length = 0;
   475};
   476
   477struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   478  typedef HandFanT NativeTableType;
   479  typedef HandFanBuilder Builder;
   480  struct Traits;
   481  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   482    return HandFanTypeTable();
   483  }
   484  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
   485    VT_LENGTH = 4
   486  };
   487  int32_t length() const {
   488    return GetField<int32_t>(VT_LENGTH, 0);
   489  }
   490  bool mutate_length(int32_t _length = 0) {
   491    return SetField<int32_t>(VT_LENGTH, _length, 0);
   492  }
   493  template<size_t Index>
   494  auto get_field() const {
   495         if constexpr (Index == 0) return length();
   496    else static_assert(Index != Index, "Invalid Field Index");
   497  }
   498  bool Verify(::flatbuffers::Verifier &verifier) const {
   499    return VerifyTableStart(verifier) &&
   500           VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
   501           verifier.EndTable();
   502  }
   503  HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   504  void UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   505  static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   506};
   507
   508struct HandFanBuilder {
   509  typedef HandFan Table;
   510  ::flatbuffers::FlatBufferBuilder &fbb_;
   511  ::flatbuffers::uoffset_t start_;
   512  void add_length(int32_t length) {
   513    fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
   514  }
   515  explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
   516        : fbb_(_fbb) {
   517    start_ = fbb_.StartTable();
   518  }
   519  ::flatbuffers::Offset<HandFan> Finish() {
   520    const auto end = fbb_.EndTable(start_);
   521    auto o = ::flatbuffers::Offset<HandFan>(end);
   522    return o;
   523  }
   524};
   525
   526inline ::flatbuffers::Offset<HandFan> CreateHandFan(
   527    ::flatbuffers::FlatBufferBuilder &_fbb,
   528    int32_t length = 0) {
   529  HandFanBuilder builder_(_fbb);
   530  builder_.add_length(length);
   531  return builder_.Finish();
   532}
   533
   534struct HandFan::Traits {
   535  using type = HandFan;
   536  static auto constexpr Create = CreateHandFan;
   537  static constexpr auto name = "HandFan";
   538  static constexpr auto fully_qualified_name = "HandFan";
   539  static constexpr size_t fields_number = 1;
   540  static constexpr std::array<const char *, fields_number> field_names = {
   541    "length"
   542  };
   543  template<size_t Index>
   544  using FieldType = decltype(std::declval<type>().get_field<Index>());
   545};
   546
   547::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   548
   549struct MovieT : public ::flatbuffers::NativeTable {
   550  typedef Movie TableType;
   551  CharacterUnion main_character{};
   552  std::vector<CharacterUnion> characters{};
   553};
   554
   555struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   556  typedef MovieT NativeTableType;
   557  typedef MovieBuilder Builder;
   558  struct Traits;
   559  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
   560    return MovieTypeTable();
   561  }
   562  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
   563    VT_MAIN_CHARACTER_TYPE = 4,
   564    VT_MAIN_CHARACTER = 6,
   565    VT_CHARACTERS_TYPE = 8,
   566    VT_CHARACTERS = 10
   567  };
   568  Character main_character_type() const {
   569    return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
   570  }
   571  const void *main_character() const {
   572    return GetPointer<const void *>(VT_MAIN_CHARACTER);
   573  }
   574  const Attacker *main_character_as_MuLan() const {
   575    return main_character_type() == Character::MuLan ? static_cast<const Attacker *>(main_character()) : nullptr;
   576  }
   577  const Rapunzel *main_character_as_Rapunzel() const {
   578    return main_character_type() == Character::Rapunzel ? static_cast<const Rapunzel *>(main_character()) : nullptr;
   579  }
   580  const BookReader *main_character_as_Belle() const {
   581    return main_character_type() == Character::Belle ? static_cast<const BookReader *>(main_character()) : nullptr;
   582  }
   583  const BookReader *main_character_as_BookFan() const {
   584    return main_character_type() == Character::BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
   585  }
   586  const ::flatbuffers::String *main_character_as_Other() const {
   587    return main_character_type() == Character::Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
   588  }
   589  const ::flatbuffers::String *main_character_as_Unused() const {
   590    return main_character_type() == Character::Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
   591  }
   592  void *mutable_main_character() {
   593    return GetPointer<void *>(VT_MAIN_CHARACTER);
   594  }
   595  const ::flatbuffers::Vector<Character> *characters_type() const {
   596    return GetPointer<const ::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
   597  }
   598  ::flatbuffers::Vector<Character> *mutable_characters_type() {
   599    return GetPointer<::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
   600  }
   601  const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
   602    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   603  }
   604  ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
   605    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   606  }
   607  template<size_t Index>
   608  auto get_field() const {
   609         if constexpr (Index == 0) return main_character_type();
   610    else if constexpr (Index == 1) return main_character();
   611    else if constexpr (Index == 2) return characters_type();
   612    else if constexpr (Index == 3) return characters();
   613    else static_assert(Index != Index, "Invalid Field Index");
   614  }
   615  bool Verify(::flatbuffers::Verifier &verifier) const {
   616    return VerifyTableStart(verifier) &&
   617           VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
   618           VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
   619           VerifyCharacter(verifier, main_character(), main_character_type()) &&
   620           VerifyOffset(verifier, VT_CHARACTERS_TYPE) &&
   621           verifier.VerifyVector(characters_type()) &&
   622           VerifyOffset(verifier, VT_CHARACTERS) &&
   623           verifier.VerifyVector(characters()) &&
   624           VerifyCharacterVector(verifier, characters(), characters_type()) &&
   625           verifier.EndTable();
   626  }
   627  MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   628  void UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
   629  static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   630};
   631
   632struct MovieBuilder {
   633  typedef Movie Table;
   634  ::flatbuffers::FlatBufferBuilder &fbb_;
   635  ::flatbuffers::uoffset_t start_;
   636  void add_main_character_type(Character main_character_type) {
   637    fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
   638  }
   639  void add_main_character(::flatbuffers::Offset<void> main_character) {
   640    fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
   641  }
   642  void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type) {
   643    fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
   644  }
   645  void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
   646    fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
   647  }
   648  explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
   649        : fbb_(_fbb) {
   650    start_ = fbb_.StartTable();
   651  }
   652  ::flatbuffers::Offset<Movie> Finish() {
   653    const auto end = fbb_.EndTable(start_);
   654    auto o = ::flatbuffers::Offset<Movie>(end);
   655    return o;
   656  }
   657};
   658
   659inline ::flatbuffers::Offset<Movie> CreateMovie(
   660    ::flatbuffers::FlatBufferBuilder &_fbb,
   661    Character main_character_type = Character::NONE,
   662    ::flatbuffers::Offset<void> main_character = 0,
   663    ::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
   664    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
   665  MovieBuilder builder_(_fbb);
   666  builder_.add_characters(characters);
   667  builder_.add_characters_type(characters_type);
   668  builder_.add_main_character(main_character);
   669  builder_.add_main_character_type(main_character_type);
   670  return builder_.Finish();
   671}
   672
   673struct Movie::Traits {
   674  using type = Movie;
   675  static auto constexpr Create = CreateMovie;
   676  static constexpr auto name = "Movie";
   677  static constexpr auto fully_qualified_name = "Movie";
   678  static constexpr size_t fields_number = 4;
   679  static constexpr std::array<const char *, fields_number> field_names = {
   680    "main_character_type",
   681    "main_character",
   682    "characters_type",
   683    "characters"
   684  };
   685  template<size_t Index>
   686  using FieldType = decltype(std::declval<type>().get_field<Index>());
   687};
   688
   689inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
   690    ::flatbuffers::FlatBufferBuilder &_fbb,
   691    Character main_character_type = Character::NONE,
   692    ::flatbuffers::Offset<void> main_character = 0,
   693    const std::vector<Character> *characters_type = nullptr,
   694    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
   695  auto characters_type__ = characters_type ? _fbb.CreateVector<Character>(*characters_type) : 0;
   696  auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
   697  return CreateMovie(
   698      _fbb,
   699      main_character_type,
   700      main_character,
   701      characters_type__,
   702      characters__);
   703}
   704
   705::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
   706
   707inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
   708  auto _o = std::make_unique<AttackerT>();
   709  UnPackTo(_o.get(), _resolver);
   710  return _o.release();
   711}
   712
   713inline void Attacker::UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
   714  (void)_o;
   715  (void)_resolver;
   716  { auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; }
   717}
   718
   719inline ::flatbuffers::Offset<Attacker> Attacker::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   720  return CreateAttacker(_fbb, _o, _rehasher);
   721}
   722
   723inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   724  (void)_rehasher;
   725  (void)_o;
   726  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   727  auto _sword_attack_damage = _o->sword_attack_damage;
   728  return CreateAttacker(
   729      _fbb,
   730      _sword_attack_damage);
   731}
   732
   733inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
   734  auto _o = std::make_unique<HandFanT>();
   735  UnPackTo(_o.get(), _resolver);
   736  return _o.release();
   737}
   738
   739inline void HandFan::UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
   740  (void)_o;
   741  (void)_resolver;
   742  { auto _e = length(); _o->length = _e; }
   743}
   744
   745inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   746  return CreateHandFan(_fbb, _o, _rehasher);
   747}
   748
   749inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   750  (void)_rehasher;
   751  (void)_o;
   752  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   753  auto _length = _o->length;
   754  return CreateHandFan(
   755      _fbb,
   756      _length);
   757}
   758
   759inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
   760  auto _o = std::make_unique<MovieT>();
   761  UnPackTo(_o.get(), _resolver);
   762  return _o.release();
   763}
   764
   765inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
   766  (void)_o;
   767  (void)_resolver;
   768  { auto _e = main_character_type(); _o->main_character.type = _e; }
   769  { auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
   770  { auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
   771  { auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
   772}
   773
   774inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   775  return CreateMovie(_fbb, _o, _rehasher);
   776}
   777
   778inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
   779  (void)_rehasher;
   780  (void)_o;
   781  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   782  auto _main_character_type = _o->main_character.type;
   783  auto _main_character = _o->main_character.Pack(_fbb);
   784  auto _characters_type = _o->characters.size() ? _fbb.CreateVector<Character>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].type; }, &_va) : 0;
   785  auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
   786  return CreateMovie(
   787      _fbb,
   788      _main_character_type,
   789      _main_character,
   790      _characters_type,
   791      _characters);
   792}
   793
   794inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
   795  switch (type) {
   796    case Character::NONE: {
   797      return true;
   798    }
   799    case Character::MuLan: {
   800      auto ptr = reinterpret_cast<const Attacker *>(obj);
   801      return verifier.VerifyTable(ptr);
   802    }
   803    case Character::Rapunzel: {
   804      return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
   805    }
   806    case Character::Belle: {
   807      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
   808    }
   809    case Character::BookFan: {
   810      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
   811    }
   812    case Character::Other: {
   813      auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
   814      return verifier.VerifyString(ptr);
   815    }
   816    case Character::Unused: {
   817      auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
   818      return verifier.VerifyString(ptr);
   819    }
   820    default: return true;
   821  }
   822}
   823
   824inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
   825  if (!values || !types) return !values && !types;
   826  if (values->size() != types->size()) return false;
   827  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
   828    if (!VerifyCharacter(
   829        verifier,  values->Get(i), types->GetEnum<Character>(i))) {
   830      return false;
   831    }
   832  }
   833  return true;
   834}
   835
   836inline void *CharacterUnion::UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver) {
   837  (void)resolver;
   838  switch (type) {
   839    case Character::MuLan: {
   840      auto ptr = reinterpret_cast<const Attacker *>(obj);
   841      return ptr->UnPack(resolver);
   842    }
   843    case Character::Rapunzel: {
   844      auto ptr = reinterpret_cast<const Rapunzel *>(obj);
   845      return new Rapunzel(*ptr);
   846    }
   847    case Character::Belle: {
   848      auto ptr = reinterpret_cast<const BookReader *>(obj);
   849      return new BookReader(*ptr);
   850    }
   851    case Character::BookFan: {
   852      auto ptr = reinterpret_cast<const BookReader *>(obj);
   853      return new BookReader(*ptr);
   854    }
   855    case Character::Other: {
   856      auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
   857      return new std::string(ptr->c_str(), ptr->size());
   858    }
   859    case Character::Unused: {
   860      auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
   861      return new std::string(ptr->c_str(), ptr->size());
   862    }
   863    default: return nullptr;
   864  }
   865}
   866
   867inline ::flatbuffers::Offset<void> CharacterUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
   868  (void)_rehasher;
   869  switch (type) {
   870    case Character::MuLan: {
   871      auto ptr = reinterpret_cast<const AttackerT *>(value);
   872      return CreateAttacker(_fbb, ptr, _rehasher).Union();
   873    }
   874    case Character::Rapunzel: {
   875      auto ptr = reinterpret_cast<const Rapunzel *>(value);
   876      return _fbb.CreateStruct(*ptr).Union();
   877    }
   878    case Character::Belle: {
   879      auto ptr = reinterpret_cast<const BookReader *>(value);
   880      return _fbb.CreateStruct(*ptr).Union();
   881    }
   882    case Character::BookFan: {
   883      auto ptr = reinterpret_cast<const BookReader *>(value);
   884      return _fbb.CreateStruct(*ptr).Union();
   885    }
   886    case Character::Other: {
   887      auto ptr = reinterpret_cast<const std::string *>(value);
   888      return _fbb.CreateString(*ptr).Union();
   889    }
   890    case Character::Unused: {
   891      auto ptr = reinterpret_cast<const std::string *>(value);
   892      return _fbb.CreateString(*ptr).Union();
   893    }
   894    default: return 0;
   895  }
   896}
   897
   898inline CharacterUnion::CharacterUnion(const CharacterUnion &u) : type(u.type), value(nullptr) {
   899  switch (type) {
   900    case Character::MuLan: {
   901      value = new AttackerT(*reinterpret_cast<AttackerT *>(u.value));
   902      break;
   903    }
   904    case Character::Rapunzel: {
   905      value = new Rapunzel(*reinterpret_cast<Rapunzel *>(u.value));
   906      break;
   907    }
   908    case Character::Belle: {
   909      value = new BookReader(*reinterpret_cast<BookReader *>(u.value));
   910      break;
   911    }
   912    case Character::BookFan: {
   913      value = new BookReader(*reinterpret_cast<BookReader *>(u.value));
   914      break;
   915    }
   916    case Character::Other: {
   917      value = new std::string(*reinterpret_cast<std::string *>(u.value));
   918      break;
   919    }
   920    case Character::Unused: {
   921      value = new std::string(*reinterpret_cast<std::string *>(u.value));
   922      break;
   923    }
   924    default:
   925      break;
   926  }
   927}
   928
   929inline void CharacterUnion::Reset() {
   930  switch (type) {
   931    case Character::MuLan: {
   932      auto ptr = reinterpret_cast<AttackerT *>(value);
   933      delete ptr;
   934      break;
   935    }
   936    case Character::Rapunzel: {
   937      auto ptr = reinterpret_cast<Rapunzel *>(value);
   938      delete ptr;
   939      break;
   940    }
   941    case Character::Belle: {
   942      auto ptr = reinterpret_cast<BookReader *>(value);
   943      delete ptr;
   944      break;
   945    }
   946    case Character::BookFan: {
   947      auto ptr = reinterpret_cast<BookReader *>(value);
   948      delete ptr;
   949      break;
   950    }
   951    case Character::Other: {
   952      auto ptr = reinterpret_cast<std::string *>(value);
   953      delete ptr;
   954      break;
   955    }
   956    case Character::Unused: {
   957      auto ptr = reinterpret_cast<std::string *>(value);
   958      delete ptr;
   959      break;
   960    }
   961    default: break;
   962  }
   963  value = nullptr;
   964  type = Character::NONE;
   965}
   966
   967inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
   968  switch (type) {
   969    case Gadget::NONE: {
   970      return true;
   971    }
   972    case Gadget::FallingTub: {
   973      return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
   974    }
   975    case Gadget::HandFan: {
   976      auto ptr = reinterpret_cast<const HandFan *>(obj);
   977      return verifier.VerifyTable(ptr);
   978    }
   979    default: return true;
   980  }
   981}
   982
   983inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
   984  if (!values || !types) return !values && !types;
   985  if (values->size() != types->size()) return false;
   986  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
   987    if (!VerifyGadget(
   988        verifier,  values->Get(i), types->GetEnum<Gadget>(i))) {
   989      return false;
   990    }
   991  }
   992  return true;
   993}
   994
   995inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver) {
   996  (void)resolver;
   997  switch (type) {
   998    case Gadget::FallingTub: {
   999      auto ptr = reinterpret_cast<const FallingTub *>(obj);
  1000      return new FallingTub(*ptr);
  1001    }
  1002    case Gadget::HandFan: {
  1003      auto ptr = reinterpret_cast<const HandFan *>(obj);
  1004      return ptr->UnPack(resolver);
  1005    }
  1006    default: return nullptr;
  1007  }
  1008}
  1009
  1010inline ::flatbuffers::Offset<void> GadgetUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
  1011  (void)_rehasher;
  1012  switch (type) {
  1013    case Gadget::FallingTub: {
  1014      auto ptr = reinterpret_cast<const FallingTub *>(value);
  1015      return _fbb.CreateStruct(*ptr).Union();
  1016    }
  1017    case Gadget::HandFan: {
  1018      auto ptr = reinterpret_cast<const HandFanT *>(value);
  1019      return CreateHandFan(_fbb, ptr, _rehasher).Union();
  1020    }
  1021    default: return 0;
  1022  }
  1023}
  1024
  1025inline GadgetUnion::GadgetUnion(const GadgetUnion &u) : type(u.type), value(nullptr) {
  1026  switch (type) {
  1027    case Gadget::FallingTub: {
  1028      value = new FallingTub(*reinterpret_cast<FallingTub *>(u.value));
  1029      break;
  1030    }
  1031    case Gadget::HandFan: {
  1032      value = new HandFanT(*reinterpret_cast<HandFanT *>(u.value));
  1033      break;
  1034    }
  1035    default:
  1036      break;
  1037  }
  1038}
  1039
  1040inline void GadgetUnion::Reset() {
  1041  switch (type) {
  1042    case Gadget::FallingTub: {
  1043      auto ptr = reinterpret_cast<FallingTub *>(value);
  1044      delete ptr;
  1045      break;
  1046    }
  1047    case Gadget::HandFan: {
  1048      auto ptr = reinterpret_cast<HandFanT *>(value);
  1049      delete ptr;
  1050      break;
  1051    }
  1052    default: break;
  1053  }
  1054  value = nullptr;
  1055  type = Gadget::NONE;
  1056}
  1057
  1058inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
  1059  static const ::flatbuffers::TypeCode type_codes[] = {
  1060    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
  1061    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
  1062    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
  1063    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
  1064    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
  1065    { ::flatbuffers::ET_STRING, 0, -1 },
  1066    { ::flatbuffers::ET_STRING, 0, -1 }
  1067  };
  1068  static const ::flatbuffers::TypeFunction type_refs[] = {
  1069    AttackerTypeTable,
  1070    RapunzelTypeTable,
  1071    BookReaderTypeTable
  1072  };
  1073  static const char * const names[] = {
  1074    "NONE",
  1075    "MuLan",
  1076    "Rapunzel",
  1077    "Belle",
  1078    "BookFan",
  1079    "Other",
  1080    "Unused"
  1081  };
  1082  static const ::flatbuffers::TypeTable tt = {
  1083    ::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
  1084  };
  1085  return &tt;
  1086}
  1087
  1088inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
  1089  static const ::flatbuffers::TypeCode type_codes[] = {
  1090    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
  1091    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
  1092    { ::flatbuffers::ET_SEQUENCE, 0, 1 }
  1093  };
  1094  static const ::flatbuffers::TypeFunction type_refs[] = {
  1095    FallingTubTypeTable,
  1096    HandFanTypeTable
  1097  };
  1098  static const char * const names[] = {
  1099    "NONE",
  1100    "FallingTub",
  1101    "HandFan"
  1102  };
  1103  static const ::flatbuffers::TypeTable tt = {
  1104    ::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
  1105  };
  1106  return &tt;
  1107}
  1108
  1109inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
  1110  static const ::flatbuffers::TypeCode type_codes[] = {
  1111    { ::flatbuffers::ET_INT, 0, -1 }
  1112  };
  1113  static const char * const names[] = {
  1114    "sword_attack_damage"
  1115  };
  1116  static const ::flatbuffers::TypeTable tt = {
  1117    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  1118  };
  1119  return &tt;
  1120}
  1121
  1122inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
  1123  static const ::flatbuffers::TypeCode type_codes[] = {
  1124    { ::flatbuffers::ET_INT, 0, -1 }
  1125  };
  1126  static const int64_t values[] = { 0, 4 };
  1127  static const char * const names[] = {
  1128    "hair_length"
  1129  };
  1130  static const ::flatbuffers::TypeTable tt = {
  1131    ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
  1132  };
  1133  return &tt;
  1134}
  1135
  1136inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
  1137  static const ::flatbuffers::TypeCode type_codes[] = {
  1138    { ::flatbuffers::ET_INT, 0, -1 }
  1139  };
  1140  static const int64_t values[] = { 0, 4 };
  1141  static const char * const names[] = {
  1142    "books_read"
  1143  };
  1144  static const ::flatbuffers::TypeTable tt = {
  1145    ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
  1146  };
  1147  return &tt;
  1148}
  1149
  1150inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
  1151  static const ::flatbuffers::TypeCode type_codes[] = {
  1152    { ::flatbuffers::ET_INT, 0, -1 }
  1153  };
  1154  static const int64_t values[] = { 0, 4 };
  1155  static const char * const names[] = {
  1156    "weight"
  1157  };
  1158  static const ::flatbuffers::TypeTable tt = {
  1159    ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
  1160  };
  1161  return &tt;
  1162}
  1163
  1164inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
  1165  static const ::flatbuffers::TypeCode type_codes[] = {
  1166    { ::flatbuffers::ET_INT, 0, -1 }
  1167  };
  1168  static const char * const names[] = {
  1169    "length"
  1170  };
  1171  static const ::flatbuffers::TypeTable tt = {
  1172    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  1173  };
  1174  return &tt;
  1175}
  1176
  1177inline const ::flatbuffers::TypeTable *MovieTypeTable() {
  1178  static const ::flatbuffers::TypeCode type_codes[] = {
  1179    { ::flatbuffers::ET_UTYPE, 0, 0 },
  1180    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
  1181    { ::flatbuffers::ET_UTYPE, 1, 0 },
  1182    { ::flatbuffers::ET_SEQUENCE, 1, 0 }
  1183  };
  1184  static const ::flatbuffers::TypeFunction type_refs[] = {
  1185    CharacterTypeTable
  1186  };
  1187  static const char * const names[] = {
  1188    "main_character_type",
  1189    "main_character",
  1190    "characters_type",
  1191    "characters"
  1192  };
  1193  static const ::flatbuffers::TypeTable tt = {
  1194    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
  1195  };
  1196  return &tt;
  1197}
  1198
  1199inline const Movie *GetMovie(const void *buf) {
  1200  return ::flatbuffers::GetRoot<Movie>(buf);
  1201}
  1202
  1203inline const Movie *GetSizePrefixedMovie(const void *buf) {
  1204  return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
  1205}
  1206
  1207inline Movie *GetMutableMovie(void *buf) {
  1208  return ::flatbuffers::GetMutableRoot<Movie>(buf);
  1209}
  1210
  1211inline Movie *GetMutableSizePrefixedMovie(void *buf) {
  1212  return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
  1213}
  1214
  1215inline const char *MovieIdentifier() {
  1216  return "MOVI";
  1217}
  1218
  1219inline bool MovieBufferHasIdentifier(const void *buf) {
  1220  return ::flatbuffers::BufferHasIdentifier(
  1221      buf, MovieIdentifier());
  1222}
  1223
  1224inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
  1225  return ::flatbuffers::BufferHasIdentifier(
  1226      buf, MovieIdentifier(), true);
  1227}
  1228
  1229inline bool VerifyMovieBuffer(
  1230    ::flatbuffers::Verifier &verifier) {
  1231  return verifier.VerifyBuffer<Movie>(MovieIdentifier());
  1232}
  1233
  1234inline bool VerifySizePrefixedMovieBuffer(
  1235    ::flatbuffers::Verifier &verifier) {
  1236  return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
  1237}
  1238
  1239inline void FinishMovieBuffer(
  1240    ::flatbuffers::FlatBufferBuilder &fbb,
  1241    ::flatbuffers::Offset<Movie> root) {
  1242  fbb.Finish(root, MovieIdentifier());
  1243}
  1244
  1245inline void FinishSizePrefixedMovieBuffer(
  1246    ::flatbuffers::FlatBufferBuilder &fbb,
  1247    ::flatbuffers::Offset<Movie> root) {
  1248  fbb.FinishSizePrefixed(root, MovieIdentifier());
  1249}
  1250
  1251inline std::unique_ptr<MovieT> UnPackMovie(
  1252    const void *buf,
  1253    const ::flatbuffers::resolver_function_t *res = nullptr) {
  1254  return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
  1255}
  1256
  1257inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie(
  1258    const void *buf,
  1259    const ::flatbuffers::resolver_function_t *res = nullptr) {
  1260  return std::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
  1261}
  1262
  1263#endif  // FLATBUFFERS_GENERATED_UNIONVECTOR_H_

View as plain text