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