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