xref: /aosp_15_r20/external/flatbuffers/tests/cpp17/generated_cpp17/union_vector_generated.h (revision 890232f25432b36107d06881e0a25aaa6b473652) 
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.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12               FLATBUFFERS_VERSION_MINOR == 0 &&
13               FLATBUFFERS_VERSION_REVISION == 7,
14              "Non-compatible flatbuffers version included");
15 
16 struct Attacker;
17 struct AttackerBuilder;
18 struct AttackerT;
19 
20 struct Rapunzel;
21 
22 struct BookReader;
23 
24 struct FallingTub;
25 
26 struct HandFan;
27 struct HandFanBuilder;
28 struct HandFanT;
29 
30 struct Movie;
31 struct MovieBuilder;
32 struct MovieT;
33 
34 inline const flatbuffers::TypeTable *AttackerTypeTable();
35 
36 inline const flatbuffers::TypeTable *RapunzelTypeTable();
37 
38 inline const flatbuffers::TypeTable *BookReaderTypeTable();
39 
40 inline const flatbuffers::TypeTable *FallingTubTypeTable();
41 
42 inline const flatbuffers::TypeTable *HandFanTypeTable();
43 
44 inline const flatbuffers::TypeTable *MovieTypeTable();
45 
46 enum 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 
EnumValuesCharacter()58 inline 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 
EnumNamesCharacter()71 inline 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 
EnumNameCharacter(Character e)85 inline 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 
91 struct CharacterUnion {
92   Character type;
93   void *value;
94 
CharacterUnionCharacterUnion95   CharacterUnion() : type(Character::NONE), value(nullptr) {}
CharacterUnionCharacterUnion96   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; }
~CharacterUnionCharacterUnion104   ~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 
AsMuLanCharacterUnion111   AttackerT *AsMuLan() {
112     return type == Character::MuLan ?
113       reinterpret_cast<AttackerT *>(value) : nullptr;
114   }
AsMuLanCharacterUnion115   const AttackerT *AsMuLan() const {
116     return type == Character::MuLan ?
117       reinterpret_cast<const AttackerT *>(value) : nullptr;
118   }
AsRapunzelCharacterUnion119   Rapunzel *AsRapunzel() {
120     return type == Character::Rapunzel ?
121       reinterpret_cast<Rapunzel *>(value) : nullptr;
122   }
AsRapunzelCharacterUnion123   const Rapunzel *AsRapunzel() const {
124     return type == Character::Rapunzel ?
125       reinterpret_cast<const Rapunzel *>(value) : nullptr;
126   }
AsBelleCharacterUnion127   BookReader *AsBelle() {
128     return type == Character::Belle ?
129       reinterpret_cast<BookReader *>(value) : nullptr;
130   }
AsBelleCharacterUnion131   const BookReader *AsBelle() const {
132     return type == Character::Belle ?
133       reinterpret_cast<const BookReader *>(value) : nullptr;
134   }
AsBookFanCharacterUnion135   BookReader *AsBookFan() {
136     return type == Character::BookFan ?
137       reinterpret_cast<BookReader *>(value) : nullptr;
138   }
AsBookFanCharacterUnion139   const BookReader *AsBookFan() const {
140     return type == Character::BookFan ?
141       reinterpret_cast<const BookReader *>(value) : nullptr;
142   }
AsOtherCharacterUnion143   std::string *AsOther() {
144     return type == Character::Other ?
145       reinterpret_cast<std::string *>(value) : nullptr;
146   }
AsOtherCharacterUnion147   const std::string *AsOther() const {
148     return type == Character::Other ?
149       reinterpret_cast<const std::string *>(value) : nullptr;
150   }
AsUnusedCharacterUnion151   std::string *AsUnused() {
152     return type == Character::Unused ?
153       reinterpret_cast<std::string *>(value) : nullptr;
154   }
AsUnusedCharacterUnion155   const std::string *AsUnused() const {
156     return type == Character::Unused ?
157       reinterpret_cast<const std::string *>(value) : nullptr;
158   }
159 };
160 
161 bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
162 bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Character> *types);
163 
164 enum class Gadget : uint8_t {
165   NONE = 0,
166   FallingTub = 1,
167   HandFan = 2,
168   MIN = NONE,
169   MAX = HandFan
170 };
171 
EnumValuesGadget()172 inline const Gadget (&EnumValuesGadget())[3] {
173   static const Gadget values[] = {
174     Gadget::NONE,
175     Gadget::FallingTub,
176     Gadget::HandFan
177   };
178   return values;
179 }
180 
EnumNamesGadget()181 inline 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 
EnumNameGadget(Gadget e)191 inline 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 
197 template<typename T> struct GadgetTraits {
198   static const Gadget enum_value = Gadget::NONE;
199 };
200 
201 template<> struct GadgetTraits<FallingTub> {
202   static const Gadget enum_value = Gadget::FallingTub;
203 };
204 
205 template<> struct GadgetTraits<HandFan> {
206   static const Gadget enum_value = Gadget::HandFan;
207 };
208 
209 template<typename T> struct GadgetUnionTraits {
210   static const Gadget enum_value = Gadget::NONE;
211 };
212 
213 template<> struct GadgetUnionTraits<FallingTub> {
214   static const Gadget enum_value = Gadget::FallingTub;
215 };
216 
217 template<> struct GadgetUnionTraits<HandFanT> {
218   static const Gadget enum_value = Gadget::HandFan;
219 };
220 
221 struct 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 
269 bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type);
270 bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Gadget> *types);
271 
272 FLATBUFFERS_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 };
299 FLATBUFFERS_STRUCT_END(Rapunzel, 4);
300 
301 struct 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 
313 FLATBUFFERS_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 };
340 FLATBUFFERS_STRUCT_END(BookReader, 4);
341 
342 struct 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 
354 FLATBUFFERS_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 };
381 FLATBUFFERS_STRUCT_END(FallingTub, 4);
382 
383 struct 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 
395 struct AttackerT : public flatbuffers::NativeTable {
396   typedef Attacker TableType;
397   int32_t sword_attack_damage = 0;
398 };
399 
400 struct 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 
431 struct 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 
449 inline 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 
457 struct 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 
472 struct HandFanT : public flatbuffers::NativeTable {
473   typedef HandFan TableType;
474   int32_t length = 0;
475 };
476 
477 struct 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 
508 struct 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 
526 inline 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 
534 struct 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 
549 struct MovieT : public flatbuffers::NativeTable {
550   typedef Movie TableType;
551   CharacterUnion main_character{};
552   std::vector<CharacterUnion> characters{};
553 };
554 
555 struct 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 
632 struct 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 
659 inline 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 
673 struct 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 
689 inline 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 
707 inline 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 
713 inline 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 
719 inline 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 
723 inline 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 
733 inline 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 
739 inline 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 
745 inline 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 
749 inline 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 
759 inline 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 
765 inline 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)); } } }
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); } } }
772 }
773 
774 inline 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 
778 inline 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 
794 inline 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 
824 inline 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 
836 inline 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 
867 inline 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 
898 inline 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 
929 inline 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 
967 inline 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 
983 inline 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 
995 inline 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 
1010 inline 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 
1025 inline 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 
1040 inline 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 
1058 inline 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 
1088 inline 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 
1109 inline 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 
1122 inline 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 
1136 inline 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 
1150 inline 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 
1164 inline 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 
1177 inline 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 
1199 inline const Movie *GetMovie(const void *buf) {
1200   return flatbuffers::GetRoot<Movie>(buf);
1201 }
1202 
1203 inline const Movie *GetSizePrefixedMovie(const void *buf) {
1204   return flatbuffers::GetSizePrefixedRoot<Movie>(buf);
1205 }
1206 
1207 inline Movie *GetMutableMovie(void *buf) {
1208   return flatbuffers::GetMutableRoot<Movie>(buf);
1209 }
1210 
1211 inline Movie *GetMutableSizePrefixedMovie(void *buf) {
1212   return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
1213 }
1214 
1215 inline const char *MovieIdentifier() {
1216   return "MOVI";
1217 }
1218 
1219 inline bool MovieBufferHasIdentifier(const void *buf) {
1220   return flatbuffers::BufferHasIdentifier(
1221       buf, MovieIdentifier());
1222 }
1223 
1224 inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
1225   return flatbuffers::BufferHasIdentifier(
1226       buf, MovieIdentifier(), true);
1227 }
1228 
1229 inline bool VerifyMovieBuffer(
1230     flatbuffers::Verifier &verifier) {
1231   return verifier.VerifyBuffer<Movie>(MovieIdentifier());
1232 }
1233 
1234 inline bool VerifySizePrefixedMovieBuffer(
1235     flatbuffers::Verifier &verifier) {
1236   return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
1237 }
1238 
1239 inline void FinishMovieBuffer(
1240     flatbuffers::FlatBufferBuilder &fbb,
1241     flatbuffers::Offset<Movie> root) {
1242   fbb.Finish(root, MovieIdentifier());
1243 }
1244 
1245 inline void FinishSizePrefixedMovieBuffer(
1246     flatbuffers::FlatBufferBuilder &fbb,
1247     flatbuffers::Offset<Movie> root) {
1248   fbb.FinishSizePrefixed(root, MovieIdentifier());
1249 }
1250 
1251 inline 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 
1257 inline 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_
1264