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 struct Attacker;
10 struct AttackerT;
11
12 struct Rapunzel;
13
14 struct BookReader;
15
16 struct Movie;
17 struct MovieT;
18
19 bool operator==(const AttackerT &lhs, const AttackerT &rhs);
20 bool operator!=(const AttackerT &lhs, const AttackerT &rhs);
21 bool operator==(const Rapunzel &lhs, const Rapunzel &rhs);
22 bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs);
23 bool operator==(const BookReader &lhs, const BookReader &rhs);
24 bool operator!=(const BookReader &lhs, const BookReader &rhs);
25 bool operator==(const MovieT &lhs, const MovieT &rhs);
26 bool operator!=(const MovieT &lhs, const MovieT &rhs);
27
28 inline const flatbuffers::TypeTable *AttackerTypeTable();
29
30 inline const flatbuffers::TypeTable *RapunzelTypeTable();
31
32 inline const flatbuffers::TypeTable *BookReaderTypeTable();
33
34 inline const flatbuffers::TypeTable *MovieTypeTable();
35
36 enum Character {
37 Character_NONE = 0,
38 Character_MuLan = 1,
39 Character_Rapunzel = 2,
40 Character_Belle = 3,
41 Character_BookFan = 4,
42 Character_Other = 5,
43 Character_Unused = 6,
44 Character_MIN = Character_NONE,
45 Character_MAX = Character_Unused
46 };
47
EnumValuesCharacter()48 inline const Character (&EnumValuesCharacter())[7] {
49 static const Character values[] = {
50 Character_NONE,
51 Character_MuLan,
52 Character_Rapunzel,
53 Character_Belle,
54 Character_BookFan,
55 Character_Other,
56 Character_Unused
57 };
58 return values;
59 }
60
EnumNamesCharacter()61 inline const char * const *EnumNamesCharacter() {
62 static const char * const names[] = {
63 "NONE",
64 "MuLan",
65 "Rapunzel",
66 "Belle",
67 "BookFan",
68 "Other",
69 "Unused",
70 nullptr
71 };
72 return names;
73 }
74
EnumNameCharacter(Character e)75 inline const char *EnumNameCharacter(Character e) {
76 if (e < Character_NONE || e > Character_Unused) return "";
77 const size_t index = static_cast<size_t>(e);
78 return EnumNamesCharacter()[index];
79 }
80
81 struct CharacterUnion {
82 Character type;
83 void *value;
84
CharacterUnionCharacterUnion85 CharacterUnion() : type(Character_NONE), value(nullptr) {}
CharacterUnionCharacterUnion86 CharacterUnion(CharacterUnion&& u) FLATBUFFERS_NOEXCEPT :
87 type(Character_NONE), value(nullptr)
88 { std::swap(type, u.type); std::swap(value, u.value); }
89 CharacterUnion(const CharacterUnion &) FLATBUFFERS_NOEXCEPT;
90 CharacterUnion &operator=(const CharacterUnion &u) FLATBUFFERS_NOEXCEPT
91 { CharacterUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
92 CharacterUnion &operator=(CharacterUnion &&u) FLATBUFFERS_NOEXCEPT
93 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
~CharacterUnionCharacterUnion94 ~CharacterUnion() { Reset(); }
95
96 void Reset();
97
98 static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver);
99 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
100
AsMuLanCharacterUnion101 AttackerT *AsMuLan() {
102 return type == Character_MuLan ?
103 reinterpret_cast<AttackerT *>(value) : nullptr;
104 }
AsMuLanCharacterUnion105 const AttackerT *AsMuLan() const {
106 return type == Character_MuLan ?
107 reinterpret_cast<const AttackerT *>(value) : nullptr;
108 }
AsRapunzelCharacterUnion109 Rapunzel *AsRapunzel() {
110 return type == Character_Rapunzel ?
111 reinterpret_cast<Rapunzel *>(value) : nullptr;
112 }
AsRapunzelCharacterUnion113 const Rapunzel *AsRapunzel() const {
114 return type == Character_Rapunzel ?
115 reinterpret_cast<const Rapunzel *>(value) : nullptr;
116 }
AsBelleCharacterUnion117 BookReader *AsBelle() {
118 return type == Character_Belle ?
119 reinterpret_cast<BookReader *>(value) : nullptr;
120 }
AsBelleCharacterUnion121 const BookReader *AsBelle() const {
122 return type == Character_Belle ?
123 reinterpret_cast<const BookReader *>(value) : nullptr;
124 }
AsBookFanCharacterUnion125 BookReader *AsBookFan() {
126 return type == Character_BookFan ?
127 reinterpret_cast<BookReader *>(value) : nullptr;
128 }
AsBookFanCharacterUnion129 const BookReader *AsBookFan() const {
130 return type == Character_BookFan ?
131 reinterpret_cast<const BookReader *>(value) : nullptr;
132 }
AsOtherCharacterUnion133 std::string *AsOther() {
134 return type == Character_Other ?
135 reinterpret_cast<std::string *>(value) : nullptr;
136 }
AsOtherCharacterUnion137 const std::string *AsOther() const {
138 return type == Character_Other ?
139 reinterpret_cast<const std::string *>(value) : nullptr;
140 }
AsUnusedCharacterUnion141 std::string *AsUnused() {
142 return type == Character_Unused ?
143 reinterpret_cast<std::string *>(value) : nullptr;
144 }
AsUnusedCharacterUnion145 const std::string *AsUnused() const {
146 return type == Character_Unused ?
147 reinterpret_cast<const std::string *>(value) : nullptr;
148 }
149 };
150
151
152 inline bool operator==(const CharacterUnion &lhs, const CharacterUnion &rhs) {
153 if (lhs.type != rhs.type) return false;
154 switch (lhs.type) {
155 case Character_NONE: {
156 return true;
157 }
158 case Character_MuLan: {
159 return *(reinterpret_cast<const AttackerT *>(lhs.value)) ==
160 *(reinterpret_cast<const AttackerT *>(rhs.value));
161 }
162 case Character_Rapunzel: {
163 return *(reinterpret_cast<const Rapunzel *>(lhs.value)) ==
164 *(reinterpret_cast<const Rapunzel *>(rhs.value));
165 }
166 case Character_Belle: {
167 return *(reinterpret_cast<const BookReader *>(lhs.value)) ==
168 *(reinterpret_cast<const BookReader *>(rhs.value));
169 }
170 case Character_BookFan: {
171 return *(reinterpret_cast<const BookReader *>(lhs.value)) ==
172 *(reinterpret_cast<const BookReader *>(rhs.value));
173 }
174 case Character_Other: {
175 return *(reinterpret_cast<const std::string *>(lhs.value)) ==
176 *(reinterpret_cast<const std::string *>(rhs.value));
177 }
178 case Character_Unused: {
179 return *(reinterpret_cast<const std::string *>(lhs.value)) ==
180 *(reinterpret_cast<const std::string *>(rhs.value));
181 }
182 default: {
183 return false;
184 }
185 }
186 }
187
188 inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
189 return !(lhs == rhs);
190 }
191
192 bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
193 bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
194
195 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
196 private:
197 int32_t hair_length_;
198
199 public:
MiniReflectTypeTable()200 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
201 return RapunzelTypeTable();
202 }
Rapunzel()203 Rapunzel() {
204 memset(static_cast<void *>(this), 0, sizeof(Rapunzel));
205 }
Rapunzel(int32_t _hair_length)206 Rapunzel(int32_t _hair_length)
207 : hair_length_(flatbuffers::EndianScalar(_hair_length)) {
208 }
hair_length()209 int32_t hair_length() const {
210 return flatbuffers::EndianScalar(hair_length_);
211 }
mutate_hair_length(int32_t _hair_length)212 void mutate_hair_length(int32_t _hair_length) {
213 flatbuffers::WriteScalar(&hair_length_, _hair_length);
214 }
215 };
216 FLATBUFFERS_STRUCT_END(Rapunzel, 4);
217
218 inline bool operator==(const Rapunzel &lhs, const Rapunzel &rhs) {
219 return
220 (lhs.hair_length() == rhs.hair_length());
221 }
222
223 inline bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs) {
224 return !(lhs == rhs);
225 }
226
227
228 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
229 private:
230 int32_t books_read_;
231
232 public:
MiniReflectTypeTable()233 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
234 return BookReaderTypeTable();
235 }
BookReader()236 BookReader() {
237 memset(static_cast<void *>(this), 0, sizeof(BookReader));
238 }
BookReader(int32_t _books_read)239 BookReader(int32_t _books_read)
240 : books_read_(flatbuffers::EndianScalar(_books_read)) {
241 }
books_read()242 int32_t books_read() const {
243 return flatbuffers::EndianScalar(books_read_);
244 }
mutate_books_read(int32_t _books_read)245 void mutate_books_read(int32_t _books_read) {
246 flatbuffers::WriteScalar(&books_read_, _books_read);
247 }
248 };
249 FLATBUFFERS_STRUCT_END(BookReader, 4);
250
251 inline bool operator==(const BookReader &lhs, const BookReader &rhs) {
252 return
253 (lhs.books_read() == rhs.books_read());
254 }
255
256 inline bool operator!=(const BookReader &lhs, const BookReader &rhs) {
257 return !(lhs == rhs);
258 }
259
260
261 struct AttackerT : public flatbuffers::NativeTable {
262 typedef Attacker TableType;
263 int32_t sword_attack_damage;
AttackerTAttackerT264 AttackerT()
265 : sword_attack_damage(0) {
266 }
267 };
268
269 inline bool operator==(const AttackerT &lhs, const AttackerT &rhs) {
270 return
271 (lhs.sword_attack_damage == rhs.sword_attack_damage);
272 }
273
274 inline bool operator!=(const AttackerT &lhs, const AttackerT &rhs) {
275 return !(lhs == rhs);
276 }
277
278
279 struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
280 typedef AttackerT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS281 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
282 return AttackerTypeTable();
283 }
284 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
285 VT_SWORD_ATTACK_DAMAGE = 4
286 };
sword_attack_damageFLATBUFFERS_FINAL_CLASS287 int32_t sword_attack_damage() const {
288 return GetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, 0);
289 }
mutate_sword_attack_damageFLATBUFFERS_FINAL_CLASS290 bool mutate_sword_attack_damage(int32_t _sword_attack_damage) {
291 return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
292 }
VerifyFLATBUFFERS_FINAL_CLASS293 bool Verify(flatbuffers::Verifier &verifier) const {
294 return VerifyTableStart(verifier) &&
295 VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE) &&
296 verifier.EndTable();
297 }
298 AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
299 void UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
300 static flatbuffers::Offset<Attacker> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
301 };
302
303 struct AttackerBuilder {
304 flatbuffers::FlatBufferBuilder &fbb_;
305 flatbuffers::uoffset_t start_;
add_sword_attack_damageAttackerBuilder306 void add_sword_attack_damage(int32_t sword_attack_damage) {
307 fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
308 }
AttackerBuilderAttackerBuilder309 explicit AttackerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
310 : fbb_(_fbb) {
311 start_ = fbb_.StartTable();
312 }
313 AttackerBuilder &operator=(const AttackerBuilder &);
FinishAttackerBuilder314 flatbuffers::Offset<Attacker> Finish() {
315 const auto end = fbb_.EndTable(start_);
316 auto o = flatbuffers::Offset<Attacker>(end);
317 return o;
318 }
319 };
320
321 inline flatbuffers::Offset<Attacker> CreateAttacker(
322 flatbuffers::FlatBufferBuilder &_fbb,
323 int32_t sword_attack_damage = 0) {
324 AttackerBuilder builder_(_fbb);
325 builder_.add_sword_attack_damage(sword_attack_damage);
326 return builder_.Finish();
327 }
328
329 flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
330
331 struct MovieT : public flatbuffers::NativeTable {
332 typedef Movie TableType;
333 CharacterUnion main_character;
334 std::vector<CharacterUnion> characters;
MovieTMovieT335 MovieT() {
336 }
337 };
338
339 inline bool operator==(const MovieT &lhs, const MovieT &rhs) {
340 return
341 (lhs.main_character == rhs.main_character) &&
342 (lhs.characters == rhs.characters);
343 }
344
345 inline bool operator!=(const MovieT &lhs, const MovieT &rhs) {
346 return !(lhs == rhs);
347 }
348
349
350 struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
351 typedef MovieT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS352 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
353 return MovieTypeTable();
354 }
355 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
356 VT_MAIN_CHARACTER_TYPE = 4,
357 VT_MAIN_CHARACTER = 6,
358 VT_CHARACTERS_TYPE = 8,
359 VT_CHARACTERS = 10
360 };
main_character_typeFLATBUFFERS_FINAL_CLASS361 Character main_character_type() const {
362 return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
363 }
mutate_main_character_typeFLATBUFFERS_FINAL_CLASS364 bool mutate_main_character_type(Character _main_character_type) {
365 return SetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(_main_character_type), 0);
366 }
main_characterFLATBUFFERS_FINAL_CLASS367 const void *main_character() const {
368 return GetPointer<const void *>(VT_MAIN_CHARACTER);
369 }
main_character_as_MuLanFLATBUFFERS_FINAL_CLASS370 const Attacker *main_character_as_MuLan() const {
371 return main_character_type() == Character_MuLan ? static_cast<const Attacker *>(main_character()) : nullptr;
372 }
main_character_as_RapunzelFLATBUFFERS_FINAL_CLASS373 const Rapunzel *main_character_as_Rapunzel() const {
374 return main_character_type() == Character_Rapunzel ? static_cast<const Rapunzel *>(main_character()) : nullptr;
375 }
main_character_as_BelleFLATBUFFERS_FINAL_CLASS376 const BookReader *main_character_as_Belle() const {
377 return main_character_type() == Character_Belle ? static_cast<const BookReader *>(main_character()) : nullptr;
378 }
main_character_as_BookFanFLATBUFFERS_FINAL_CLASS379 const BookReader *main_character_as_BookFan() const {
380 return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
381 }
main_character_as_OtherFLATBUFFERS_FINAL_CLASS382 const flatbuffers::String *main_character_as_Other() const {
383 return main_character_type() == Character_Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
384 }
main_character_as_UnusedFLATBUFFERS_FINAL_CLASS385 const flatbuffers::String *main_character_as_Unused() const {
386 return main_character_type() == Character_Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
387 }
mutable_main_characterFLATBUFFERS_FINAL_CLASS388 void *mutable_main_character() {
389 return GetPointer<void *>(VT_MAIN_CHARACTER);
390 }
characters_typeFLATBUFFERS_FINAL_CLASS391 const flatbuffers::Vector<uint8_t> *characters_type() const {
392 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
393 }
mutable_characters_typeFLATBUFFERS_FINAL_CLASS394 flatbuffers::Vector<uint8_t> *mutable_characters_type() {
395 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
396 }
charactersFLATBUFFERS_FINAL_CLASS397 const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const {
398 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
399 }
mutable_charactersFLATBUFFERS_FINAL_CLASS400 flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() {
401 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
402 }
VerifyFLATBUFFERS_FINAL_CLASS403 bool Verify(flatbuffers::Verifier &verifier) const {
404 return VerifyTableStart(verifier) &&
405 VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE) &&
406 VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
407 VerifyCharacter(verifier, main_character(), main_character_type()) &&
408 VerifyOffset(verifier, VT_CHARACTERS_TYPE) &&
409 verifier.VerifyVector(characters_type()) &&
410 VerifyOffset(verifier, VT_CHARACTERS) &&
411 verifier.VerifyVector(characters()) &&
412 VerifyCharacterVector(verifier, characters(), characters_type()) &&
413 verifier.EndTable();
414 }
415 MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
416 void UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
417 static flatbuffers::Offset<Movie> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
418 };
419
420 struct MovieBuilder {
421 flatbuffers::FlatBufferBuilder &fbb_;
422 flatbuffers::uoffset_t start_;
add_main_character_typeMovieBuilder423 void add_main_character_type(Character main_character_type) {
424 fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
425 }
add_main_characterMovieBuilder426 void add_main_character(flatbuffers::Offset<void> main_character) {
427 fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
428 }
add_characters_typeMovieBuilder429 void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type) {
430 fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
431 }
add_charactersMovieBuilder432 void add_characters(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters) {
433 fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
434 }
MovieBuilderMovieBuilder435 explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb)
436 : fbb_(_fbb) {
437 start_ = fbb_.StartTable();
438 }
439 MovieBuilder &operator=(const MovieBuilder &);
FinishMovieBuilder440 flatbuffers::Offset<Movie> Finish() {
441 const auto end = fbb_.EndTable(start_);
442 auto o = flatbuffers::Offset<Movie>(end);
443 return o;
444 }
445 };
446
447 inline flatbuffers::Offset<Movie> CreateMovie(
448 flatbuffers::FlatBufferBuilder &_fbb,
449 Character main_character_type = Character_NONE,
450 flatbuffers::Offset<void> main_character = 0,
451 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type = 0,
452 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) {
453 MovieBuilder builder_(_fbb);
454 builder_.add_characters(characters);
455 builder_.add_characters_type(characters_type);
456 builder_.add_main_character(main_character);
457 builder_.add_main_character_type(main_character_type);
458 return builder_.Finish();
459 }
460
461 inline flatbuffers::Offset<Movie> CreateMovieDirect(
462 flatbuffers::FlatBufferBuilder &_fbb,
463 Character main_character_type = Character_NONE,
464 flatbuffers::Offset<void> main_character = 0,
465 const std::vector<uint8_t> *characters_type = nullptr,
466 const std::vector<flatbuffers::Offset<void>> *characters = nullptr) {
467 auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0;
468 auto characters__ = characters ? _fbb.CreateVector<flatbuffers::Offset<void>>(*characters) : 0;
469 return CreateMovie(
470 _fbb,
471 main_character_type,
472 main_character,
473 characters_type__,
474 characters__);
475 }
476
477 flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
478
UnPack(const flatbuffers::resolver_function_t * _resolver)479 inline AttackerT *Attacker::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
480 auto _o = new AttackerT();
481 UnPackTo(_o, _resolver);
482 return _o;
483 }
484
UnPackTo(AttackerT * _o,const flatbuffers::resolver_function_t * _resolver)485 inline void Attacker::UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
486 (void)_o;
487 (void)_resolver;
488 { auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; };
489 }
490
Pack(flatbuffers::FlatBufferBuilder & _fbb,const AttackerT * _o,const flatbuffers::rehasher_function_t * _rehasher)491 inline flatbuffers::Offset<Attacker> Attacker::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
492 return CreateAttacker(_fbb, _o, _rehasher);
493 }
494
CreateAttacker(flatbuffers::FlatBufferBuilder & _fbb,const AttackerT * _o,const flatbuffers::rehasher_function_t * _rehasher)495 inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
496 (void)_rehasher;
497 (void)_o;
498 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
499 auto _sword_attack_damage = _o->sword_attack_damage;
500 return CreateAttacker(
501 _fbb,
502 _sword_attack_damage);
503 }
504
UnPack(const flatbuffers::resolver_function_t * _resolver)505 inline MovieT *Movie::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
506 auto _o = new MovieT();
507 UnPackTo(_o, _resolver);
508 return _o;
509 }
510
UnPackTo(MovieT * _o,const flatbuffers::resolver_function_t * _resolver)511 inline void Movie::UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver) const {
512 (void)_o;
513 (void)_resolver;
514 { auto _e = main_character_type(); _o->main_character.type = _e; };
515 { auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); };
516 { 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)); } } };
517 { 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); } } };
518 }
519
Pack(flatbuffers::FlatBufferBuilder & _fbb,const MovieT * _o,const flatbuffers::rehasher_function_t * _rehasher)520 inline flatbuffers::Offset<Movie> Movie::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
521 return CreateMovie(_fbb, _o, _rehasher);
522 }
523
CreateMovie(flatbuffers::FlatBufferBuilder & _fbb,const MovieT * _o,const flatbuffers::rehasher_function_t * _rehasher)524 inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
525 (void)_rehasher;
526 (void)_o;
527 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
528 auto _main_character_type = _o->main_character.type;
529 auto _main_character = _o->main_character.Pack(_fbb);
530 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;
531 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;
532 return CreateMovie(
533 _fbb,
534 _main_character_type,
535 _main_character,
536 _characters_type,
537 _characters);
538 }
539
VerifyCharacter(flatbuffers::Verifier & verifier,const void * obj,Character type)540 inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type) {
541 switch (type) {
542 case Character_NONE: {
543 return true;
544 }
545 case Character_MuLan: {
546 auto ptr = reinterpret_cast<const Attacker *>(obj);
547 return verifier.VerifyTable(ptr);
548 }
549 case Character_Rapunzel: {
550 return verifier.Verify<Rapunzel>(static_cast<const uint8_t *>(obj), 0);
551 }
552 case Character_Belle: {
553 return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
554 }
555 case Character_BookFan: {
556 return verifier.Verify<BookReader>(static_cast<const uint8_t *>(obj), 0);
557 }
558 case Character_Other: {
559 auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
560 return verifier.VerifyString(ptr);
561 }
562 case Character_Unused: {
563 auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
564 return verifier.VerifyString(ptr);
565 }
566 default: return false;
567 }
568 }
569
VerifyCharacterVector(flatbuffers::Verifier & verifier,const flatbuffers::Vector<flatbuffers::Offset<void>> * values,const flatbuffers::Vector<uint8_t> * types)570 inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
571 if (!values || !types) return !values && !types;
572 if (values->size() != types->size()) return false;
573 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
574 if (!VerifyCharacter(
575 verifier, values->Get(i), types->GetEnum<Character>(i))) {
576 return false;
577 }
578 }
579 return true;
580 }
581
UnPack(const void * obj,Character type,const flatbuffers::resolver_function_t * resolver)582 inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
583 switch (type) {
584 case Character_MuLan: {
585 auto ptr = reinterpret_cast<const Attacker *>(obj);
586 return ptr->UnPack(resolver);
587 }
588 case Character_Rapunzel: {
589 auto ptr = reinterpret_cast<const Rapunzel *>(obj);
590 return new Rapunzel(*ptr);
591 }
592 case Character_Belle: {
593 auto ptr = reinterpret_cast<const BookReader *>(obj);
594 return new BookReader(*ptr);
595 }
596 case Character_BookFan: {
597 auto ptr = reinterpret_cast<const BookReader *>(obj);
598 return new BookReader(*ptr);
599 }
600 case Character_Other: {
601 auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
602 return new std::string(ptr->c_str(), ptr->size());
603 }
604 case Character_Unused: {
605 auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
606 return new std::string(ptr->c_str(), ptr->size());
607 }
608 default: return nullptr;
609 }
610 }
611
Pack(flatbuffers::FlatBufferBuilder & _fbb,const flatbuffers::rehasher_function_t * _rehasher)612 inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
613 switch (type) {
614 case Character_MuLan: {
615 auto ptr = reinterpret_cast<const AttackerT *>(value);
616 return CreateAttacker(_fbb, ptr, _rehasher).Union();
617 }
618 case Character_Rapunzel: {
619 auto ptr = reinterpret_cast<const Rapunzel *>(value);
620 return _fbb.CreateStruct(*ptr).Union();
621 }
622 case Character_Belle: {
623 auto ptr = reinterpret_cast<const BookReader *>(value);
624 return _fbb.CreateStruct(*ptr).Union();
625 }
626 case Character_BookFan: {
627 auto ptr = reinterpret_cast<const BookReader *>(value);
628 return _fbb.CreateStruct(*ptr).Union();
629 }
630 case Character_Other: {
631 auto ptr = reinterpret_cast<const std::string *>(value);
632 return _fbb.CreateString(*ptr).Union();
633 }
634 case Character_Unused: {
635 auto ptr = reinterpret_cast<const std::string *>(value);
636 return _fbb.CreateString(*ptr).Union();
637 }
638 default: return 0;
639 }
640 }
641
CharacterUnion(const CharacterUnion & u)642 inline CharacterUnion::CharacterUnion(const CharacterUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
643 switch (type) {
644 case Character_MuLan: {
645 value = new AttackerT(*reinterpret_cast<AttackerT *>(u.value));
646 break;
647 }
648 case Character_Rapunzel: {
649 value = new Rapunzel(*reinterpret_cast<Rapunzel *>(u.value));
650 break;
651 }
652 case Character_Belle: {
653 value = new BookReader(*reinterpret_cast<BookReader *>(u.value));
654 break;
655 }
656 case Character_BookFan: {
657 value = new BookReader(*reinterpret_cast<BookReader *>(u.value));
658 break;
659 }
660 case Character_Other: {
661 value = new std::string(*reinterpret_cast<std::string *>(u.value));
662 break;
663 }
664 case Character_Unused: {
665 value = new std::string(*reinterpret_cast<std::string *>(u.value));
666 break;
667 }
668 default:
669 break;
670 }
671 }
672
Reset()673 inline void CharacterUnion::Reset() {
674 switch (type) {
675 case Character_MuLan: {
676 auto ptr = reinterpret_cast<AttackerT *>(value);
677 delete ptr;
678 break;
679 }
680 case Character_Rapunzel: {
681 auto ptr = reinterpret_cast<Rapunzel *>(value);
682 delete ptr;
683 break;
684 }
685 case Character_Belle: {
686 auto ptr = reinterpret_cast<BookReader *>(value);
687 delete ptr;
688 break;
689 }
690 case Character_BookFan: {
691 auto ptr = reinterpret_cast<BookReader *>(value);
692 delete ptr;
693 break;
694 }
695 case Character_Other: {
696 auto ptr = reinterpret_cast<std::string *>(value);
697 delete ptr;
698 break;
699 }
700 case Character_Unused: {
701 auto ptr = reinterpret_cast<std::string *>(value);
702 delete ptr;
703 break;
704 }
705 default: break;
706 }
707 value = nullptr;
708 type = Character_NONE;
709 }
710
CharacterTypeTable()711 inline const flatbuffers::TypeTable *CharacterTypeTable() {
712 static const flatbuffers::TypeCode type_codes[] = {
713 { flatbuffers::ET_SEQUENCE, 0, -1 },
714 { flatbuffers::ET_SEQUENCE, 0, 0 },
715 { flatbuffers::ET_SEQUENCE, 0, 1 },
716 { flatbuffers::ET_SEQUENCE, 0, 2 },
717 { flatbuffers::ET_SEQUENCE, 0, 2 },
718 { flatbuffers::ET_STRING, 0, -1 },
719 { flatbuffers::ET_STRING, 0, -1 }
720 };
721 static const flatbuffers::TypeFunction type_refs[] = {
722 AttackerTypeTable,
723 RapunzelTypeTable,
724 BookReaderTypeTable
725 };
726 static const char * const names[] = {
727 "NONE",
728 "MuLan",
729 "Rapunzel",
730 "Belle",
731 "BookFan",
732 "Other",
733 "Unused"
734 };
735 static const flatbuffers::TypeTable tt = {
736 flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, names
737 };
738 return &tt;
739 }
740
AttackerTypeTable()741 inline const flatbuffers::TypeTable *AttackerTypeTable() {
742 static const flatbuffers::TypeCode type_codes[] = {
743 { flatbuffers::ET_INT, 0, -1 }
744 };
745 static const char * const names[] = {
746 "sword_attack_damage"
747 };
748 static const flatbuffers::TypeTable tt = {
749 flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, names
750 };
751 return &tt;
752 }
753
RapunzelTypeTable()754 inline const flatbuffers::TypeTable *RapunzelTypeTable() {
755 static const flatbuffers::TypeCode type_codes[] = {
756 { flatbuffers::ET_INT, 0, -1 }
757 };
758 static const int64_t values[] = { 0, 4 };
759 static const char * const names[] = {
760 "hair_length"
761 };
762 static const flatbuffers::TypeTable tt = {
763 flatbuffers::ST_STRUCT, 1, type_codes, nullptr, values, names
764 };
765 return &tt;
766 }
767
BookReaderTypeTable()768 inline const flatbuffers::TypeTable *BookReaderTypeTable() {
769 static const flatbuffers::TypeCode type_codes[] = {
770 { flatbuffers::ET_INT, 0, -1 }
771 };
772 static const int64_t values[] = { 0, 4 };
773 static const char * const names[] = {
774 "books_read"
775 };
776 static const flatbuffers::TypeTable tt = {
777 flatbuffers::ST_STRUCT, 1, type_codes, nullptr, values, names
778 };
779 return &tt;
780 }
781
MovieTypeTable()782 inline const flatbuffers::TypeTable *MovieTypeTable() {
783 static const flatbuffers::TypeCode type_codes[] = {
784 { flatbuffers::ET_UTYPE, 0, 0 },
785 { flatbuffers::ET_SEQUENCE, 0, 0 },
786 { flatbuffers::ET_UTYPE, 1, 0 },
787 { flatbuffers::ET_SEQUENCE, 1, 0 }
788 };
789 static const flatbuffers::TypeFunction type_refs[] = {
790 CharacterTypeTable
791 };
792 static const char * const names[] = {
793 "main_character_type",
794 "main_character",
795 "characters_type",
796 "characters"
797 };
798 static const flatbuffers::TypeTable tt = {
799 flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, names
800 };
801 return &tt;
802 }
803
GetMovie(const void * buf)804 inline const Movie *GetMovie(const void *buf) {
805 return flatbuffers::GetRoot<Movie>(buf);
806 }
807
GetSizePrefixedMovie(const void * buf)808 inline const Movie *GetSizePrefixedMovie(const void *buf) {
809 return flatbuffers::GetSizePrefixedRoot<Movie>(buf);
810 }
811
GetMutableMovie(void * buf)812 inline Movie *GetMutableMovie(void *buf) {
813 return flatbuffers::GetMutableRoot<Movie>(buf);
814 }
815
MovieIdentifier()816 inline const char *MovieIdentifier() {
817 return "MOVI";
818 }
819
MovieBufferHasIdentifier(const void * buf)820 inline bool MovieBufferHasIdentifier(const void *buf) {
821 return flatbuffers::BufferHasIdentifier(
822 buf, MovieIdentifier());
823 }
824
VerifyMovieBuffer(flatbuffers::Verifier & verifier)825 inline bool VerifyMovieBuffer(
826 flatbuffers::Verifier &verifier) {
827 return verifier.VerifyBuffer<Movie>(MovieIdentifier());
828 }
829
VerifySizePrefixedMovieBuffer(flatbuffers::Verifier & verifier)830 inline bool VerifySizePrefixedMovieBuffer(
831 flatbuffers::Verifier &verifier) {
832 return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
833 }
834
FinishMovieBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<Movie> root)835 inline void FinishMovieBuffer(
836 flatbuffers::FlatBufferBuilder &fbb,
837 flatbuffers::Offset<Movie> root) {
838 fbb.Finish(root, MovieIdentifier());
839 }
840
FinishSizePrefixedMovieBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<Movie> root)841 inline void FinishSizePrefixedMovieBuffer(
842 flatbuffers::FlatBufferBuilder &fbb,
843 flatbuffers::Offset<Movie> root) {
844 fbb.FinishSizePrefixed(root, MovieIdentifier());
845 }
846
847 inline flatbuffers::unique_ptr<MovieT> UnPackMovie(
848 const void *buf,
849 const flatbuffers::resolver_function_t *res = nullptr) {
850 return flatbuffers::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
851 }
852
853 #endif // FLATBUFFERS_GENERATED_UNIONVECTOR_H_
854