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