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