1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
5 #define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
6
7 #include "flatbuffers/flatbuffers.h"
8 #include "flatbuffers/flexbuffers.h"
9 #include "flatbuffers/flex_flat_util.h"
10
11 // Ensure the included flatbuffers.h is the same version as when this file was
12 // generated, otherwise it may not be compatible.
13 static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
14 FLATBUFFERS_VERSION_MINOR == 1 &&
15 FLATBUFFERS_VERSION_REVISION == 24,
16 "Non-compatible flatbuffers version included");
17
18 namespace MyGame {
19
20 struct InParentNamespace;
21 struct InParentNamespaceBuilder;
22 struct InParentNamespaceT;
23
24 namespace Example2 {
25
26 struct Monster;
27 struct MonsterBuilder;
28 struct MonsterT;
29
30 } // namespace Example2
31
32 namespace Example {
33
34 struct Test;
35
36 struct TestSimpleTableWithEnum;
37 struct TestSimpleTableWithEnumBuilder;
38 struct TestSimpleTableWithEnumT;
39
40 struct Vec3;
41
42 struct Ability;
43
44 struct StructOfStructs;
45
46 struct StructOfStructsOfStructs;
47
48 struct Stat;
49 struct StatBuilder;
50 struct StatT;
51
52 struct Referrable;
53 struct ReferrableBuilder;
54 struct ReferrableT;
55
56 struct Monster;
57 struct MonsterBuilder;
58 struct MonsterT;
59
60 struct TypeAliases;
61 struct TypeAliasesBuilder;
62 struct TypeAliasesT;
63
64 } // namespace Example
65
66 inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable();
67
68 namespace Example2 {
69
70 inline const ::flatbuffers::TypeTable *MonsterTypeTable();
71
72 } // namespace Example2
73
74 namespace Example {
75
76 inline const ::flatbuffers::TypeTable *TestTypeTable();
77
78 inline const ::flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable();
79
80 inline const ::flatbuffers::TypeTable *Vec3TypeTable();
81
82 inline const ::flatbuffers::TypeTable *AbilityTypeTable();
83
84 inline const ::flatbuffers::TypeTable *StructOfStructsTypeTable();
85
86 inline const ::flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable();
87
88 inline const ::flatbuffers::TypeTable *StatTypeTable();
89
90 inline const ::flatbuffers::TypeTable *ReferrableTypeTable();
91
92 inline const ::flatbuffers::TypeTable *MonsterTypeTable();
93
94 inline const ::flatbuffers::TypeTable *TypeAliasesTypeTable();
95
96 /// Composite components of Monster color.
97 enum class Color : uint8_t {
98 Red = 1,
99 /// \brief color Green
100 /// Green is bit_flag with value (1u << 1)
101 Green = 2,
102 /// \brief color Blue (1u << 3)
103 Blue = 8,
104 NONE = 0,
105 ANY = 11
106 };
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Color,uint8_t)107 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Color, uint8_t)
108
109 inline const Color (&EnumValuesColor())[3] {
110 static const Color values[] = {
111 Color::Red,
112 Color::Green,
113 Color::Blue
114 };
115 return values;
116 }
117
EnumNamesColor()118 inline const char * const *EnumNamesColor() {
119 static const char * const names[9] = {
120 "Red",
121 "Green",
122 "",
123 "",
124 "",
125 "",
126 "",
127 "Blue",
128 nullptr
129 };
130 return names;
131 }
132
EnumNameColor(Color e)133 inline const char *EnumNameColor(Color e) {
134 if (::flatbuffers::IsOutRange(e, Color::Red, Color::Blue)) return "";
135 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(Color::Red);
136 return EnumNamesColor()[index];
137 }
138
139 enum class Race : int8_t {
140 None = -1,
141 Human = 0,
142 Dwarf = 1,
143 Elf = 2,
144 MIN = None,
145 MAX = Elf
146 };
147
EnumValuesRace()148 inline const Race (&EnumValuesRace())[4] {
149 static const Race values[] = {
150 Race::None,
151 Race::Human,
152 Race::Dwarf,
153 Race::Elf
154 };
155 return values;
156 }
157
EnumNamesRace()158 inline const char * const *EnumNamesRace() {
159 static const char * const names[5] = {
160 "None",
161 "Human",
162 "Dwarf",
163 "Elf",
164 nullptr
165 };
166 return names;
167 }
168
EnumNameRace(Race e)169 inline const char *EnumNameRace(Race e) {
170 if (::flatbuffers::IsOutRange(e, Race::None, Race::Elf)) return "";
171 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(Race::None);
172 return EnumNamesRace()[index];
173 }
174
175 enum class LongEnum : uint64_t {
176 LongOne = 2ULL,
177 LongTwo = 4ULL,
178 LongBig = 1099511627776ULL,
179 NONE = 0,
180 ANY = 1099511627782ULL
181 };
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(LongEnum,uint64_t)182 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(LongEnum, uint64_t)
183
184 inline const LongEnum (&EnumValuesLongEnum())[3] {
185 static const LongEnum values[] = {
186 LongEnum::LongOne,
187 LongEnum::LongTwo,
188 LongEnum::LongBig
189 };
190 return values;
191 }
192
EnumNameLongEnum(LongEnum e)193 inline const char *EnumNameLongEnum(LongEnum e) {
194 switch (e) {
195 case LongEnum::LongOne: return "LongOne";
196 case LongEnum::LongTwo: return "LongTwo";
197 case LongEnum::LongBig: return "LongBig";
198 default: return "";
199 }
200 }
201
202 enum class Any : uint8_t {
203 NONE = 0,
204 Monster = 1,
205 TestSimpleTableWithEnum = 2,
206 MyGame_Example2_Monster = 3,
207 MIN = NONE,
208 MAX = MyGame_Example2_Monster
209 };
210
EnumValuesAny()211 inline const Any (&EnumValuesAny())[4] {
212 static const Any values[] = {
213 Any::NONE,
214 Any::Monster,
215 Any::TestSimpleTableWithEnum,
216 Any::MyGame_Example2_Monster
217 };
218 return values;
219 }
220
EnumNamesAny()221 inline const char * const *EnumNamesAny() {
222 static const char * const names[5] = {
223 "NONE",
224 "Monster",
225 "TestSimpleTableWithEnum",
226 "MyGame_Example2_Monster",
227 nullptr
228 };
229 return names;
230 }
231
EnumNameAny(Any e)232 inline const char *EnumNameAny(Any e) {
233 if (::flatbuffers::IsOutRange(e, Any::NONE, Any::MyGame_Example2_Monster)) return "";
234 const size_t index = static_cast<size_t>(e);
235 return EnumNamesAny()[index];
236 }
237
238 template<typename T> struct AnyTraits {
239 static const Any enum_value = Any::NONE;
240 };
241
242 template<> struct AnyTraits<MyGame::Example::Monster> {
243 static const Any enum_value = Any::Monster;
244 };
245
246 template<> struct AnyTraits<MyGame::Example::TestSimpleTableWithEnum> {
247 static const Any enum_value = Any::TestSimpleTableWithEnum;
248 };
249
250 template<> struct AnyTraits<MyGame::Example2::Monster> {
251 static const Any enum_value = Any::MyGame_Example2_Monster;
252 };
253
254 template<typename T> struct AnyUnionTraits {
255 static const Any enum_value = Any::NONE;
256 };
257
258 template<> struct AnyUnionTraits<MyGame::Example::MonsterT> {
259 static const Any enum_value = Any::Monster;
260 };
261
262 template<> struct AnyUnionTraits<MyGame::Example::TestSimpleTableWithEnumT> {
263 static const Any enum_value = Any::TestSimpleTableWithEnum;
264 };
265
266 template<> struct AnyUnionTraits<MyGame::Example2::MonsterT> {
267 static const Any enum_value = Any::MyGame_Example2_Monster;
268 };
269
270 struct AnyUnion {
271 Any type;
272 void *value;
273
274 AnyUnion() : type(Any::NONE), value(nullptr) {}
275 AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT :
276 type(Any::NONE), value(nullptr)
277 { std::swap(type, u.type); std::swap(value, u.value); }
278 AnyUnion(const AnyUnion &);
279 AnyUnion &operator=(const AnyUnion &u)
280 { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
281 AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT
282 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
283 ~AnyUnion() { Reset(); }
284
285 void Reset();
286
287 template <typename T>
288 void Set(T&& val) {
289 typedef typename std::remove_reference<T>::type RT;
290 Reset();
291 type = AnyUnionTraits<RT>::enum_value;
292 if (type != Any::NONE) {
293 value = new RT(std::forward<T>(val));
294 }
295 }
296
297 static void *UnPack(const void *obj, Any type, const ::flatbuffers::resolver_function_t *resolver);
298 ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
299
300 MyGame::Example::MonsterT *AsMonster() {
301 return type == Any::Monster ?
302 reinterpret_cast<MyGame::Example::MonsterT *>(value) : nullptr;
303 }
304 const MyGame::Example::MonsterT *AsMonster() const {
305 return type == Any::Monster ?
306 reinterpret_cast<const MyGame::Example::MonsterT *>(value) : nullptr;
307 }
308 MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() {
309 return type == Any::TestSimpleTableWithEnum ?
310 reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value) : nullptr;
311 }
312 const MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const {
313 return type == Any::TestSimpleTableWithEnum ?
314 reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value) : nullptr;
315 }
316 MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() {
317 return type == Any::MyGame_Example2_Monster ?
318 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
319 }
320 const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const {
321 return type == Any::MyGame_Example2_Monster ?
322 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr;
323 }
324 };
325
326 bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
327 bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
328
329 enum class AnyUniqueAliases : uint8_t {
330 NONE = 0,
331 M = 1,
332 TS = 2,
333 M2 = 3,
334 MIN = NONE,
335 MAX = M2
336 };
337
338 inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] {
339 static const AnyUniqueAliases values[] = {
340 AnyUniqueAliases::NONE,
341 AnyUniqueAliases::M,
342 AnyUniqueAliases::TS,
343 AnyUniqueAliases::M2
344 };
345 return values;
346 }
347
348 inline const char * const *EnumNamesAnyUniqueAliases() {
349 static const char * const names[5] = {
350 "NONE",
351 "M",
352 "TS",
353 "M2",
354 nullptr
355 };
356 return names;
357 }
358
359 inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) {
360 if (::flatbuffers::IsOutRange(e, AnyUniqueAliases::NONE, AnyUniqueAliases::M2)) return "";
361 const size_t index = static_cast<size_t>(e);
362 return EnumNamesAnyUniqueAliases()[index];
363 }
364
365 template<typename T> struct AnyUniqueAliasesTraits {
366 static const AnyUniqueAliases enum_value = AnyUniqueAliases::NONE;
367 };
368
369 template<> struct AnyUniqueAliasesTraits<MyGame::Example::Monster> {
370 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M;
371 };
372
373 template<> struct AnyUniqueAliasesTraits<MyGame::Example::TestSimpleTableWithEnum> {
374 static const AnyUniqueAliases enum_value = AnyUniqueAliases::TS;
375 };
376
377 template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> {
378 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M2;
379 };
380
381 template<typename T> struct AnyUniqueAliasesUnionTraits {
382 static const AnyUniqueAliases enum_value = AnyUniqueAliases::NONE;
383 };
384
385 template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example::MonsterT> {
386 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M;
387 };
388
389 template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example::TestSimpleTableWithEnumT> {
390 static const AnyUniqueAliases enum_value = AnyUniqueAliases::TS;
391 };
392
393 template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example2::MonsterT> {
394 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M2;
395 };
396
397 struct AnyUniqueAliasesUnion {
398 AnyUniqueAliases type;
399 void *value;
400
401 AnyUniqueAliasesUnion() : type(AnyUniqueAliases::NONE), value(nullptr) {}
402 AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT :
403 type(AnyUniqueAliases::NONE), value(nullptr)
404 { std::swap(type, u.type); std::swap(value, u.value); }
405 AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &);
406 AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u)
407 { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
408 AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT
409 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
410 ~AnyUniqueAliasesUnion() { Reset(); }
411
412 void Reset();
413
414 template <typename T>
415 void Set(T&& val) {
416 typedef typename std::remove_reference<T>::type RT;
417 Reset();
418 type = AnyUniqueAliasesUnionTraits<RT>::enum_value;
419 if (type != AnyUniqueAliases::NONE) {
420 value = new RT(std::forward<T>(val));
421 }
422 }
423
424 static void *UnPack(const void *obj, AnyUniqueAliases type, const ::flatbuffers::resolver_function_t *resolver);
425 ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
426
427 MyGame::Example::MonsterT *AsM() {
428 return type == AnyUniqueAliases::M ?
429 reinterpret_cast<MyGame::Example::MonsterT *>(value) : nullptr;
430 }
431 const MyGame::Example::MonsterT *AsM() const {
432 return type == AnyUniqueAliases::M ?
433 reinterpret_cast<const MyGame::Example::MonsterT *>(value) : nullptr;
434 }
435 MyGame::Example::TestSimpleTableWithEnumT *AsTS() {
436 return type == AnyUniqueAliases::TS ?
437 reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value) : nullptr;
438 }
439 const MyGame::Example::TestSimpleTableWithEnumT *AsTS() const {
440 return type == AnyUniqueAliases::TS ?
441 reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value) : nullptr;
442 }
443 MyGame::Example2::MonsterT *AsM2() {
444 return type == AnyUniqueAliases::M2 ?
445 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
446 }
447 const MyGame::Example2::MonsterT *AsM2() const {
448 return type == AnyUniqueAliases::M2 ?
449 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr;
450 }
451 };
452
453 bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
454 bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
455
456 enum class AnyAmbiguousAliases : uint8_t {
457 NONE = 0,
458 M1 = 1,
459 M2 = 2,
460 M3 = 3,
461 MIN = NONE,
462 MAX = M3
463 };
464
465 inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] {
466 static const AnyAmbiguousAliases values[] = {
467 AnyAmbiguousAliases::NONE,
468 AnyAmbiguousAliases::M1,
469 AnyAmbiguousAliases::M2,
470 AnyAmbiguousAliases::M3
471 };
472 return values;
473 }
474
475 inline const char * const *EnumNamesAnyAmbiguousAliases() {
476 static const char * const names[5] = {
477 "NONE",
478 "M1",
479 "M2",
480 "M3",
481 nullptr
482 };
483 return names;
484 }
485
486 inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) {
487 if (::flatbuffers::IsOutRange(e, AnyAmbiguousAliases::NONE, AnyAmbiguousAliases::M3)) return "";
488 const size_t index = static_cast<size_t>(e);
489 return EnumNamesAnyAmbiguousAliases()[index];
490 }
491
492 struct AnyAmbiguousAliasesUnion {
493 AnyAmbiguousAliases type;
494 void *value;
495
496 AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases::NONE), value(nullptr) {}
497 AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT :
498 type(AnyAmbiguousAliases::NONE), value(nullptr)
499 { std::swap(type, u.type); std::swap(value, u.value); }
500 AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &);
501 AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u)
502 { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
503 AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT
504 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
505 ~AnyAmbiguousAliasesUnion() { Reset(); }
506
507 void Reset();
508
509 static void *UnPack(const void *obj, AnyAmbiguousAliases type, const ::flatbuffers::resolver_function_t *resolver);
510 ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
511
512 MyGame::Example::MonsterT *AsM1() {
513 return type == AnyAmbiguousAliases::M1 ?
514 reinterpret_cast<MyGame::Example::MonsterT *>(value) : nullptr;
515 }
516 const MyGame::Example::MonsterT *AsM1() const {
517 return type == AnyAmbiguousAliases::M1 ?
518 reinterpret_cast<const MyGame::Example::MonsterT *>(value) : nullptr;
519 }
520 MyGame::Example::MonsterT *AsM2() {
521 return type == AnyAmbiguousAliases::M2 ?
522 reinterpret_cast<MyGame::Example::MonsterT *>(value) : nullptr;
523 }
524 const MyGame::Example::MonsterT *AsM2() const {
525 return type == AnyAmbiguousAliases::M2 ?
526 reinterpret_cast<const MyGame::Example::MonsterT *>(value) : nullptr;
527 }
528 MyGame::Example::MonsterT *AsM3() {
529 return type == AnyAmbiguousAliases::M3 ?
530 reinterpret_cast<MyGame::Example::MonsterT *>(value) : nullptr;
531 }
532 const MyGame::Example::MonsterT *AsM3() const {
533 return type == AnyAmbiguousAliases::M3 ?
534 reinterpret_cast<const MyGame::Example::MonsterT *>(value) : nullptr;
535 }
536 };
537
538 bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
539 bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
540
541 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
542 private:
543 int16_t a_;
544 int8_t b_;
545 int8_t padding0__;
546
547 public:
548 struct Traits;
549 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
550 return TestTypeTable();
551 }
552 Test()
553 : a_(0),
554 b_(0),
555 padding0__(0) {
556 (void)padding0__;
557 }
558 Test(int16_t _a, int8_t _b)
559 : a_(::flatbuffers::EndianScalar(_a)),
560 b_(::flatbuffers::EndianScalar(_b)),
561 padding0__(0) {
562 (void)padding0__;
563 }
564 int16_t a() const {
565 return ::flatbuffers::EndianScalar(a_);
566 }
567 void mutate_a(int16_t _a) {
568 ::flatbuffers::WriteScalar(&a_, _a);
569 }
570 int8_t b() const {
571 return ::flatbuffers::EndianScalar(b_);
572 }
573 void mutate_b(int8_t _b) {
574 ::flatbuffers::WriteScalar(&b_, _b);
575 }
576 template<size_t Index>
577 auto get_field() const {
578 if constexpr (Index == 0) return a();
579 else if constexpr (Index == 1) return b();
580 else static_assert(Index != -1, "Invalid Field Index");
581 }
582 };
583 FLATBUFFERS_STRUCT_END(Test, 4);
584
585 struct Test::Traits {
586 using type = Test;
587 static constexpr auto name = "Test";
588 static constexpr auto fully_qualified_name = "MyGame.Example.Test";
589 static constexpr size_t fields_number = 2;
590 static constexpr std::array<const char *, fields_number> field_names = {
591 "a",
592 "b"
593 };
594 template<size_t Index>
595 using FieldType = decltype(std::declval<type>().get_field<Index>());
596 };
597
598 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS {
599 private:
600 float x_;
601 float y_;
602 float z_;
603 int32_t padding0__;
604 double test1_;
605 uint8_t test2_;
606 int8_t padding1__;
607 MyGame::Example::Test test3_;
608 int16_t padding2__;
609
610 public:
611 struct Traits;
612 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
613 return Vec3TypeTable();
614 }
615 Vec3()
616 : x_(0),
617 y_(0),
618 z_(0),
619 padding0__(0),
620 test1_(0),
621 test2_(0),
622 padding1__(0),
623 test3_(),
624 padding2__(0) {
625 (void)padding0__;
626 (void)padding1__;
627 (void)padding2__;
628 }
629 Vec3(float _x, float _y, float _z, double _test1, MyGame::Example::Color _test2, const MyGame::Example::Test &_test3)
630 : x_(::flatbuffers::EndianScalar(_x)),
631 y_(::flatbuffers::EndianScalar(_y)),
632 z_(::flatbuffers::EndianScalar(_z)),
633 padding0__(0),
634 test1_(::flatbuffers::EndianScalar(_test1)),
635 test2_(::flatbuffers::EndianScalar(static_cast<uint8_t>(_test2))),
636 padding1__(0),
637 test3_(_test3),
638 padding2__(0) {
639 (void)padding0__;
640 (void)padding1__;
641 (void)padding2__;
642 }
643 float x() const {
644 return ::flatbuffers::EndianScalar(x_);
645 }
646 void mutate_x(float _x) {
647 ::flatbuffers::WriteScalar(&x_, _x);
648 }
649 float y() const {
650 return ::flatbuffers::EndianScalar(y_);
651 }
652 void mutate_y(float _y) {
653 ::flatbuffers::WriteScalar(&y_, _y);
654 }
655 float z() const {
656 return ::flatbuffers::EndianScalar(z_);
657 }
658 void mutate_z(float _z) {
659 ::flatbuffers::WriteScalar(&z_, _z);
660 }
661 double test1() const {
662 return ::flatbuffers::EndianScalar(test1_);
663 }
664 void mutate_test1(double _test1) {
665 ::flatbuffers::WriteScalar(&test1_, _test1);
666 }
667 MyGame::Example::Color test2() const {
668 return static_cast<MyGame::Example::Color>(::flatbuffers::EndianScalar(test2_));
669 }
670 void mutate_test2(MyGame::Example::Color _test2) {
671 ::flatbuffers::WriteScalar(&test2_, static_cast<uint8_t>(_test2));
672 }
673 const MyGame::Example::Test &test3() const {
674 return test3_;
675 }
676 MyGame::Example::Test &mutable_test3() {
677 return test3_;
678 }
679 template<size_t Index>
680 auto get_field() const {
681 if constexpr (Index == 0) return x();
682 else if constexpr (Index == 1) return y();
683 else if constexpr (Index == 2) return z();
684 else if constexpr (Index == 3) return test1();
685 else if constexpr (Index == 4) return test2();
686 else if constexpr (Index == 5) return test3();
687 else static_assert(Index != -1, "Invalid Field Index");
688 }
689 };
690 FLATBUFFERS_STRUCT_END(Vec3, 32);
691
692 struct Vec3::Traits {
693 using type = Vec3;
694 static constexpr auto name = "Vec3";
695 static constexpr auto fully_qualified_name = "MyGame.Example.Vec3";
696 static constexpr size_t fields_number = 6;
697 static constexpr std::array<const char *, fields_number> field_names = {
698 "x",
699 "y",
700 "z",
701 "test1",
702 "test2",
703 "test3"
704 };
705 template<size_t Index>
706 using FieldType = decltype(std::declval<type>().get_field<Index>());
707 };
708
709 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS {
710 private:
711 uint32_t id_;
712 uint32_t distance_;
713
714 public:
715 struct Traits;
716 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
717 return AbilityTypeTable();
718 }
719 Ability()
720 : id_(0),
721 distance_(0) {
722 }
723 Ability(uint32_t _id, uint32_t _distance)
724 : id_(::flatbuffers::EndianScalar(_id)),
725 distance_(::flatbuffers::EndianScalar(_distance)) {
726 }
727 uint32_t id() const {
728 return ::flatbuffers::EndianScalar(id_);
729 }
730 void mutate_id(uint32_t _id) {
731 ::flatbuffers::WriteScalar(&id_, _id);
732 }
733 bool KeyCompareLessThan(const Ability * const o) const {
734 return id() < o->id();
735 }
736 int KeyCompareWithValue(uint32_t _id) const {
737 return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
738 }
739 uint32_t distance() const {
740 return ::flatbuffers::EndianScalar(distance_);
741 }
742 void mutate_distance(uint32_t _distance) {
743 ::flatbuffers::WriteScalar(&distance_, _distance);
744 }
745 template<size_t Index>
746 auto get_field() const {
747 if constexpr (Index == 0) return id();
748 else if constexpr (Index == 1) return distance();
749 else static_assert(Index != -1, "Invalid Field Index");
750 }
751 };
752 FLATBUFFERS_STRUCT_END(Ability, 8);
753
754 struct Ability::Traits {
755 using type = Ability;
756 static constexpr auto name = "Ability";
757 static constexpr auto fully_qualified_name = "MyGame.Example.Ability";
758 static constexpr size_t fields_number = 2;
759 static constexpr std::array<const char *, fields_number> field_names = {
760 "id",
761 "distance"
762 };
763 template<size_t Index>
764 using FieldType = decltype(std::declval<type>().get_field<Index>());
765 };
766
767 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructs FLATBUFFERS_FINAL_CLASS {
768 private:
769 MyGame::Example::Ability a_;
770 MyGame::Example::Test b_;
771 MyGame::Example::Ability c_;
772
773 public:
774 struct Traits;
775 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
776 return StructOfStructsTypeTable();
777 }
778 StructOfStructs()
779 : a_(),
780 b_(),
781 c_() {
782 }
783 StructOfStructs(const MyGame::Example::Ability &_a, const MyGame::Example::Test &_b, const MyGame::Example::Ability &_c)
784 : a_(_a),
785 b_(_b),
786 c_(_c) {
787 }
788 const MyGame::Example::Ability &a() const {
789 return a_;
790 }
791 MyGame::Example::Ability &mutable_a() {
792 return a_;
793 }
794 const MyGame::Example::Test &b() const {
795 return b_;
796 }
797 MyGame::Example::Test &mutable_b() {
798 return b_;
799 }
800 const MyGame::Example::Ability &c() const {
801 return c_;
802 }
803 MyGame::Example::Ability &mutable_c() {
804 return c_;
805 }
806 template<size_t Index>
807 auto get_field() const {
808 if constexpr (Index == 0) return a();
809 else if constexpr (Index == 1) return b();
810 else if constexpr (Index == 2) return c();
811 else static_assert(Index != -1, "Invalid Field Index");
812 }
813 };
814 FLATBUFFERS_STRUCT_END(StructOfStructs, 20);
815
816 struct StructOfStructs::Traits {
817 using type = StructOfStructs;
818 static constexpr auto name = "StructOfStructs";
819 static constexpr auto fully_qualified_name = "MyGame.Example.StructOfStructs";
820 static constexpr size_t fields_number = 3;
821 static constexpr std::array<const char *, fields_number> field_names = {
822 "a",
823 "b",
824 "c"
825 };
826 template<size_t Index>
827 using FieldType = decltype(std::declval<type>().get_field<Index>());
828 };
829
830 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructsOfStructs FLATBUFFERS_FINAL_CLASS {
831 private:
832 MyGame::Example::StructOfStructs a_;
833
834 public:
835 struct Traits;
836 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
837 return StructOfStructsOfStructsTypeTable();
838 }
839 StructOfStructsOfStructs()
840 : a_() {
841 }
842 StructOfStructsOfStructs(const MyGame::Example::StructOfStructs &_a)
843 : a_(_a) {
844 }
845 const MyGame::Example::StructOfStructs &a() const {
846 return a_;
847 }
848 MyGame::Example::StructOfStructs &mutable_a() {
849 return a_;
850 }
851 template<size_t Index>
852 auto get_field() const {
853 if constexpr (Index == 0) return a();
854 else static_assert(Index != -1, "Invalid Field Index");
855 }
856 };
857 FLATBUFFERS_STRUCT_END(StructOfStructsOfStructs, 20);
858
859 struct StructOfStructsOfStructs::Traits {
860 using type = StructOfStructsOfStructs;
861 static constexpr auto name = "StructOfStructsOfStructs";
862 static constexpr auto fully_qualified_name = "MyGame.Example.StructOfStructsOfStructs";
863 static constexpr size_t fields_number = 1;
864 static constexpr std::array<const char *, fields_number> field_names = {
865 "a"
866 };
867 template<size_t Index>
868 using FieldType = decltype(std::declval<type>().get_field<Index>());
869 };
870
871 } // namespace Example
872
873 struct InParentNamespaceT : public ::flatbuffers::NativeTable {
874 typedef InParentNamespace TableType;
875 };
876
877 struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
878 typedef InParentNamespaceT NativeTableType;
879 typedef InParentNamespaceBuilder Builder;
880 struct Traits;
881 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
882 return InParentNamespaceTypeTable();
883 }
884 bool Verify(::flatbuffers::Verifier &verifier) const {
885 return VerifyTableStart(verifier) &&
886 verifier.EndTable();
887 }
888 InParentNamespaceT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
889 void UnPackTo(InParentNamespaceT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
890 static ::flatbuffers::Offset<InParentNamespace> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
891 };
892
893 struct InParentNamespaceBuilder {
894 typedef InParentNamespace Table;
895 ::flatbuffers::FlatBufferBuilder &fbb_;
896 ::flatbuffers::uoffset_t start_;
897 explicit InParentNamespaceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
898 : fbb_(_fbb) {
899 start_ = fbb_.StartTable();
900 }
901 ::flatbuffers::Offset<InParentNamespace> Finish() {
902 const auto end = fbb_.EndTable(start_);
903 auto o = ::flatbuffers::Offset<InParentNamespace>(end);
904 return o;
905 }
906 };
907
908 inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(
909 ::flatbuffers::FlatBufferBuilder &_fbb) {
910 InParentNamespaceBuilder builder_(_fbb);
911 return builder_.Finish();
912 }
913
914 struct InParentNamespace::Traits {
915 using type = InParentNamespace;
916 static auto constexpr Create = CreateInParentNamespace;
917 static constexpr auto name = "InParentNamespace";
918 static constexpr auto fully_qualified_name = "MyGame.InParentNamespace";
919 static constexpr size_t fields_number = 0;
920 static constexpr std::array<const char *, fields_number> field_names = {};
921 };
922
923 ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
924
925 namespace Example2 {
926
927 struct MonsterT : public ::flatbuffers::NativeTable {
928 typedef Monster TableType;
929 };
930
931 struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
932 typedef MonsterT NativeTableType;
933 typedef MonsterBuilder Builder;
934 struct Traits;
935 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
936 return MonsterTypeTable();
937 }
938 bool Verify(::flatbuffers::Verifier &verifier) const {
939 return VerifyTableStart(verifier) &&
940 verifier.EndTable();
941 }
942 MonsterT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
943 void UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
944 static ::flatbuffers::Offset<Monster> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
945 };
946
947 struct MonsterBuilder {
948 typedef Monster Table;
949 ::flatbuffers::FlatBufferBuilder &fbb_;
950 ::flatbuffers::uoffset_t start_;
951 explicit MonsterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
952 : fbb_(_fbb) {
953 start_ = fbb_.StartTable();
954 }
955 ::flatbuffers::Offset<Monster> Finish() {
956 const auto end = fbb_.EndTable(start_);
957 auto o = ::flatbuffers::Offset<Monster>(end);
958 return o;
959 }
960 };
961
962 inline ::flatbuffers::Offset<Monster> CreateMonster(
963 ::flatbuffers::FlatBufferBuilder &_fbb) {
964 MonsterBuilder builder_(_fbb);
965 return builder_.Finish();
966 }
967
968 struct Monster::Traits {
969 using type = Monster;
970 static auto constexpr Create = CreateMonster;
971 static constexpr auto name = "Monster";
972 static constexpr auto fully_qualified_name = "MyGame.Example2.Monster";
973 static constexpr size_t fields_number = 0;
974 static constexpr std::array<const char *, fields_number> field_names = {};
975 };
976
977 ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
978
979 } // namespace Example2
980
981 namespace Example {
982
983 struct TestSimpleTableWithEnumT : public ::flatbuffers::NativeTable {
984 typedef TestSimpleTableWithEnum TableType;
985 MyGame::Example::Color color = MyGame::Example::Color::Green;
986 };
987
988 struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
989 typedef TestSimpleTableWithEnumT NativeTableType;
990 typedef TestSimpleTableWithEnumBuilder Builder;
991 struct Traits;
992 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
993 return TestSimpleTableWithEnumTypeTable();
994 }
995 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
996 VT_COLOR = 4
997 };
998 MyGame::Example::Color color() const {
999 return static_cast<MyGame::Example::Color>(GetField<uint8_t>(VT_COLOR, 2));
1000 }
1001 bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
1002 return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
1003 }
1004 template<size_t Index>
1005 auto get_field() const {
1006 if constexpr (Index == 0) return color();
1007 else static_assert(Index != -1, "Invalid Field Index");
1008 }
1009 bool Verify(::flatbuffers::Verifier &verifier) const {
1010 return VerifyTableStart(verifier) &&
1011 VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
1012 verifier.EndTable();
1013 }
1014 TestSimpleTableWithEnumT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1015 void UnPackTo(TestSimpleTableWithEnumT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1016 static ::flatbuffers::Offset<TestSimpleTableWithEnum> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1017 };
1018
1019 struct TestSimpleTableWithEnumBuilder {
1020 typedef TestSimpleTableWithEnum Table;
1021 ::flatbuffers::FlatBufferBuilder &fbb_;
1022 ::flatbuffers::uoffset_t start_;
1023 void add_color(MyGame::Example::Color color) {
1024 fbb_.AddElement<uint8_t>(TestSimpleTableWithEnum::VT_COLOR, static_cast<uint8_t>(color), 2);
1025 }
1026 explicit TestSimpleTableWithEnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1027 : fbb_(_fbb) {
1028 start_ = fbb_.StartTable();
1029 }
1030 ::flatbuffers::Offset<TestSimpleTableWithEnum> Finish() {
1031 const auto end = fbb_.EndTable(start_);
1032 auto o = ::flatbuffers::Offset<TestSimpleTableWithEnum>(end);
1033 return o;
1034 }
1035 };
1036
1037 inline ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(
1038 ::flatbuffers::FlatBufferBuilder &_fbb,
1039 MyGame::Example::Color color = MyGame::Example::Color::Green) {
1040 TestSimpleTableWithEnumBuilder builder_(_fbb);
1041 builder_.add_color(color);
1042 return builder_.Finish();
1043 }
1044
1045 struct TestSimpleTableWithEnum::Traits {
1046 using type = TestSimpleTableWithEnum;
1047 static auto constexpr Create = CreateTestSimpleTableWithEnum;
1048 static constexpr auto name = "TestSimpleTableWithEnum";
1049 static constexpr auto fully_qualified_name = "MyGame.Example.TestSimpleTableWithEnum";
1050 static constexpr size_t fields_number = 1;
1051 static constexpr std::array<const char *, fields_number> field_names = {
1052 "color"
1053 };
1054 template<size_t Index>
1055 using FieldType = decltype(std::declval<type>().get_field<Index>());
1056 };
1057
1058 ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1059
1060 struct StatT : public ::flatbuffers::NativeTable {
1061 typedef Stat TableType;
1062 std::string id{};
1063 int64_t val = 0;
1064 uint16_t count = 0;
1065 };
1066
1067 struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1068 typedef StatT NativeTableType;
1069 typedef StatBuilder Builder;
1070 struct Traits;
1071 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
1072 return StatTypeTable();
1073 }
1074 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1075 VT_ID = 4,
1076 VT_VAL = 6,
1077 VT_COUNT = 8
1078 };
1079 const ::flatbuffers::String *id() const {
1080 return GetPointer<const ::flatbuffers::String *>(VT_ID);
1081 }
1082 ::flatbuffers::String *mutable_id() {
1083 return GetPointer<::flatbuffers::String *>(VT_ID);
1084 }
1085 int64_t val() const {
1086 return GetField<int64_t>(VT_VAL, 0);
1087 }
1088 bool mutate_val(int64_t _val = 0) {
1089 return SetField<int64_t>(VT_VAL, _val, 0);
1090 }
1091 uint16_t count() const {
1092 return GetField<uint16_t>(VT_COUNT, 0);
1093 }
1094 bool mutate_count(uint16_t _count = 0) {
1095 return SetField<uint16_t>(VT_COUNT, _count, 0);
1096 }
1097 bool KeyCompareLessThan(const Stat * const o) const {
1098 return count() < o->count();
1099 }
1100 int KeyCompareWithValue(uint16_t _count) const {
1101 return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
1102 }
1103 template<size_t Index>
1104 auto get_field() const {
1105 if constexpr (Index == 0) return id();
1106 else if constexpr (Index == 1) return val();
1107 else if constexpr (Index == 2) return count();
1108 else static_assert(Index != -1, "Invalid Field Index");
1109 }
1110 bool Verify(::flatbuffers::Verifier &verifier) const {
1111 return VerifyTableStart(verifier) &&
1112 VerifyOffset(verifier, VT_ID) &&
1113 verifier.VerifyString(id()) &&
1114 VerifyField<int64_t>(verifier, VT_VAL, 8) &&
1115 VerifyField<uint16_t>(verifier, VT_COUNT, 2) &&
1116 verifier.EndTable();
1117 }
1118 StatT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1119 void UnPackTo(StatT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1120 static ::flatbuffers::Offset<Stat> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1121 };
1122
1123 struct StatBuilder {
1124 typedef Stat Table;
1125 ::flatbuffers::FlatBufferBuilder &fbb_;
1126 ::flatbuffers::uoffset_t start_;
1127 void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
1128 fbb_.AddOffset(Stat::VT_ID, id);
1129 }
1130 void add_val(int64_t val) {
1131 fbb_.AddElement<int64_t>(Stat::VT_VAL, val, 0);
1132 }
1133 void add_count(uint16_t count) {
1134 fbb_.AddElement<uint16_t>(Stat::VT_COUNT, count, 0);
1135 }
1136 explicit StatBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1137 : fbb_(_fbb) {
1138 start_ = fbb_.StartTable();
1139 }
1140 ::flatbuffers::Offset<Stat> Finish() {
1141 const auto end = fbb_.EndTable(start_);
1142 auto o = ::flatbuffers::Offset<Stat>(end);
1143 return o;
1144 }
1145 };
1146
1147 inline ::flatbuffers::Offset<Stat> CreateStat(
1148 ::flatbuffers::FlatBufferBuilder &_fbb,
1149 ::flatbuffers::Offset<::flatbuffers::String> id = 0,
1150 int64_t val = 0,
1151 uint16_t count = 0) {
1152 StatBuilder builder_(_fbb);
1153 builder_.add_val(val);
1154 builder_.add_id(id);
1155 builder_.add_count(count);
1156 return builder_.Finish();
1157 }
1158
1159 struct Stat::Traits {
1160 using type = Stat;
1161 static auto constexpr Create = CreateStat;
1162 static constexpr auto name = "Stat";
1163 static constexpr auto fully_qualified_name = "MyGame.Example.Stat";
1164 static constexpr size_t fields_number = 3;
1165 static constexpr std::array<const char *, fields_number> field_names = {
1166 "id",
1167 "val",
1168 "count"
1169 };
1170 template<size_t Index>
1171 using FieldType = decltype(std::declval<type>().get_field<Index>());
1172 };
1173
1174 inline ::flatbuffers::Offset<Stat> CreateStatDirect(
1175 ::flatbuffers::FlatBufferBuilder &_fbb,
1176 const char *id = nullptr,
1177 int64_t val = 0,
1178 uint16_t count = 0) {
1179 auto id__ = id ? _fbb.CreateString(id) : 0;
1180 return MyGame::Example::CreateStat(
1181 _fbb,
1182 id__,
1183 val,
1184 count);
1185 }
1186
1187 ::flatbuffers::Offset<Stat> CreateStat(::flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1188
1189 struct ReferrableT : public ::flatbuffers::NativeTable {
1190 typedef Referrable TableType;
1191 uint64_t id = 0;
1192 };
1193
1194 struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1195 typedef ReferrableT NativeTableType;
1196 typedef ReferrableBuilder Builder;
1197 struct Traits;
1198 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
1199 return ReferrableTypeTable();
1200 }
1201 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1202 VT_ID = 4
1203 };
1204 uint64_t id() const {
1205 return GetField<uint64_t>(VT_ID, 0);
1206 }
1207 bool mutate_id(uint64_t _id = 0) {
1208 return SetField<uint64_t>(VT_ID, _id, 0);
1209 }
1210 bool KeyCompareLessThan(const Referrable * const o) const {
1211 return id() < o->id();
1212 }
1213 int KeyCompareWithValue(uint64_t _id) const {
1214 return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
1215 }
1216 template<size_t Index>
1217 auto get_field() const {
1218 if constexpr (Index == 0) return id();
1219 else static_assert(Index != -1, "Invalid Field Index");
1220 }
1221 bool Verify(::flatbuffers::Verifier &verifier) const {
1222 return VerifyTableStart(verifier) &&
1223 VerifyField<uint64_t>(verifier, VT_ID, 8) &&
1224 verifier.EndTable();
1225 }
1226 ReferrableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1227 void UnPackTo(ReferrableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1228 static ::flatbuffers::Offset<Referrable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1229 };
1230
1231 struct ReferrableBuilder {
1232 typedef Referrable Table;
1233 ::flatbuffers::FlatBufferBuilder &fbb_;
1234 ::flatbuffers::uoffset_t start_;
1235 void add_id(uint64_t id) {
1236 fbb_.AddElement<uint64_t>(Referrable::VT_ID, id, 0);
1237 }
1238 explicit ReferrableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1239 : fbb_(_fbb) {
1240 start_ = fbb_.StartTable();
1241 }
1242 ::flatbuffers::Offset<Referrable> Finish() {
1243 const auto end = fbb_.EndTable(start_);
1244 auto o = ::flatbuffers::Offset<Referrable>(end);
1245 return o;
1246 }
1247 };
1248
1249 inline ::flatbuffers::Offset<Referrable> CreateReferrable(
1250 ::flatbuffers::FlatBufferBuilder &_fbb,
1251 uint64_t id = 0) {
1252 ReferrableBuilder builder_(_fbb);
1253 builder_.add_id(id);
1254 return builder_.Finish();
1255 }
1256
1257 struct Referrable::Traits {
1258 using type = Referrable;
1259 static auto constexpr Create = CreateReferrable;
1260 static constexpr auto name = "Referrable";
1261 static constexpr auto fully_qualified_name = "MyGame.Example.Referrable";
1262 static constexpr size_t fields_number = 1;
1263 static constexpr std::array<const char *, fields_number> field_names = {
1264 "id"
1265 };
1266 template<size_t Index>
1267 using FieldType = decltype(std::declval<type>().get_field<Index>());
1268 };
1269
1270 ::flatbuffers::Offset<Referrable> CreateReferrable(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1271
1272 struct MonsterT : public ::flatbuffers::NativeTable {
1273 typedef Monster TableType;
1274 std::unique_ptr<MyGame::Example::Vec3> pos{};
1275 int16_t mana = 150;
1276 int16_t hp = 100;
1277 std::string name{};
1278 std::vector<uint8_t> inventory{};
1279 MyGame::Example::Color color = MyGame::Example::Color::Blue;
1280 MyGame::Example::AnyUnion test{};
1281 std::vector<MyGame::Example::Test> test4{};
1282 std::vector<std::string> testarrayofstring{};
1283 std::vector<std::unique_ptr<MyGame::Example::MonsterT>> testarrayoftables{};
1284 std::unique_ptr<MyGame::Example::MonsterT> enemy{};
1285 std::vector<uint8_t> testnestedflatbuffer{};
1286 std::unique_ptr<MyGame::Example::StatT> testempty{};
1287 bool testbool = false;
1288 int32_t testhashs32_fnv1 = 0;
1289 uint32_t testhashu32_fnv1 = 0;
1290 int64_t testhashs64_fnv1 = 0;
1291 uint64_t testhashu64_fnv1 = 0;
1292 int32_t testhashs32_fnv1a = 0;
1293 Stat *testhashu32_fnv1a = nullptr;
1294 int64_t testhashs64_fnv1a = 0;
1295 uint64_t testhashu64_fnv1a = 0;
1296 std::vector<bool> testarrayofbools{};
1297 float testf = 3.14159f;
1298 float testf2 = 3.0f;
1299 float testf3 = 0.0f;
1300 std::vector<std::string> testarrayofstring2{};
1301 std::vector<MyGame::Example::Ability> testarrayofsortedstruct{};
1302 std::vector<uint8_t> flex{};
1303 std::vector<MyGame::Example::Test> test5{};
1304 std::vector<int64_t> vector_of_longs{};
1305 std::vector<double> vector_of_doubles{};
1306 std::unique_ptr<MyGame::InParentNamespaceT> parent_namespace_test{};
1307 std::vector<std::unique_ptr<MyGame::Example::ReferrableT>> vector_of_referrables{};
1308 ReferrableT *single_weak_reference = nullptr;
1309 std::vector<ReferrableT *> vector_of_weak_references{};
1310 std::vector<std::unique_ptr<MyGame::Example::ReferrableT>> vector_of_strong_referrables{};
1311 ReferrableT *co_owning_reference = nullptr;
1312 std::vector<std::unique_ptr<ReferrableT>> vector_of_co_owning_references{};
1313 ReferrableT *non_owning_reference = nullptr;
1314 std::vector<ReferrableT *> vector_of_non_owning_references{};
1315 MyGame::Example::AnyUniqueAliasesUnion any_unique{};
1316 MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{};
1317 std::vector<MyGame::Example::Color> vector_of_enums{};
1318 MyGame::Example::Race signed_enum = MyGame::Example::Race::None;
1319 std::vector<uint8_t> testrequirednestedflatbuffer{};
1320 std::vector<std::unique_ptr<MyGame::Example::StatT>> scalar_key_sorted_tables{};
1321 MyGame::Example::Test native_inline{};
1322 MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
1323 MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne;
1324 float nan_default = std::numeric_limits<float>::quiet_NaN();
1325 float inf_default = std::numeric_limits<float>::infinity();
1326 float positive_inf_default = std::numeric_limits<float>::infinity();
1327 float infinity_default = std::numeric_limits<float>::infinity();
1328 float positive_infinity_default = std::numeric_limits<float>::infinity();
1329 float negative_inf_default = -std::numeric_limits<float>::infinity();
1330 float negative_infinity_default = -std::numeric_limits<float>::infinity();
1331 double double_inf_default = std::numeric_limits<double>::infinity();
1332 MonsterT() = default;
1333 MonsterT(const MonsterT &o);
1334 MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
1335 MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT;
1336 };
1337
1338 /// an example documentation comment: "monster object"
1339 struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1340 typedef MonsterT NativeTableType;
1341 typedef MonsterBuilder Builder;
1342 struct Traits;
1343 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
1344 return MonsterTypeTable();
1345 }
1346 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1347 VT_POS = 4,
1348 VT_MANA = 6,
1349 VT_HP = 8,
1350 VT_NAME = 10,
1351 VT_INVENTORY = 14,
1352 VT_COLOR = 16,
1353 VT_TEST_TYPE = 18,
1354 VT_TEST = 20,
1355 VT_TEST4 = 22,
1356 VT_TESTARRAYOFSTRING = 24,
1357 VT_TESTARRAYOFTABLES = 26,
1358 VT_ENEMY = 28,
1359 VT_TESTNESTEDFLATBUFFER = 30,
1360 VT_TESTEMPTY = 32,
1361 VT_TESTBOOL = 34,
1362 VT_TESTHASHS32_FNV1 = 36,
1363 VT_TESTHASHU32_FNV1 = 38,
1364 VT_TESTHASHS64_FNV1 = 40,
1365 VT_TESTHASHU64_FNV1 = 42,
1366 VT_TESTHASHS32_FNV1A = 44,
1367 VT_TESTHASHU32_FNV1A = 46,
1368 VT_TESTHASHS64_FNV1A = 48,
1369 VT_TESTHASHU64_FNV1A = 50,
1370 VT_TESTARRAYOFBOOLS = 52,
1371 VT_TESTF = 54,
1372 VT_TESTF2 = 56,
1373 VT_TESTF3 = 58,
1374 VT_TESTARRAYOFSTRING2 = 60,
1375 VT_TESTARRAYOFSORTEDSTRUCT = 62,
1376 VT_FLEX = 64,
1377 VT_TEST5 = 66,
1378 VT_VECTOR_OF_LONGS = 68,
1379 VT_VECTOR_OF_DOUBLES = 70,
1380 VT_PARENT_NAMESPACE_TEST = 72,
1381 VT_VECTOR_OF_REFERRABLES = 74,
1382 VT_SINGLE_WEAK_REFERENCE = 76,
1383 VT_VECTOR_OF_WEAK_REFERENCES = 78,
1384 VT_VECTOR_OF_STRONG_REFERRABLES = 80,
1385 VT_CO_OWNING_REFERENCE = 82,
1386 VT_VECTOR_OF_CO_OWNING_REFERENCES = 84,
1387 VT_NON_OWNING_REFERENCE = 86,
1388 VT_VECTOR_OF_NON_OWNING_REFERENCES = 88,
1389 VT_ANY_UNIQUE_TYPE = 90,
1390 VT_ANY_UNIQUE = 92,
1391 VT_ANY_AMBIGUOUS_TYPE = 94,
1392 VT_ANY_AMBIGUOUS = 96,
1393 VT_VECTOR_OF_ENUMS = 98,
1394 VT_SIGNED_ENUM = 100,
1395 VT_TESTREQUIREDNESTEDFLATBUFFER = 102,
1396 VT_SCALAR_KEY_SORTED_TABLES = 104,
1397 VT_NATIVE_INLINE = 106,
1398 VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
1399 VT_LONG_ENUM_NORMAL_DEFAULT = 110,
1400 VT_NAN_DEFAULT = 112,
1401 VT_INF_DEFAULT = 114,
1402 VT_POSITIVE_INF_DEFAULT = 116,
1403 VT_INFINITY_DEFAULT = 118,
1404 VT_POSITIVE_INFINITY_DEFAULT = 120,
1405 VT_NEGATIVE_INF_DEFAULT = 122,
1406 VT_NEGATIVE_INFINITY_DEFAULT = 124,
1407 VT_DOUBLE_INF_DEFAULT = 126
1408 };
1409 const MyGame::Example::Vec3 *pos() const {
1410 return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
1411 }
1412 MyGame::Example::Vec3 *mutable_pos() {
1413 return GetStruct<MyGame::Example::Vec3 *>(VT_POS);
1414 }
1415 int16_t mana() const {
1416 return GetField<int16_t>(VT_MANA, 150);
1417 }
1418 bool mutate_mana(int16_t _mana = 150) {
1419 return SetField<int16_t>(VT_MANA, _mana, 150);
1420 }
1421 int16_t hp() const {
1422 return GetField<int16_t>(VT_HP, 100);
1423 }
1424 bool mutate_hp(int16_t _hp = 100) {
1425 return SetField<int16_t>(VT_HP, _hp, 100);
1426 }
1427 const ::flatbuffers::String *name() const {
1428 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1429 }
1430 ::flatbuffers::String *mutable_name() {
1431 return GetPointer<::flatbuffers::String *>(VT_NAME);
1432 }
1433 bool KeyCompareLessThan(const Monster * const o) const {
1434 return *name() < *o->name();
1435 }
1436 int KeyCompareWithValue(const char *_name) const {
1437 return strcmp(name()->c_str(), _name);
1438 }
1439 template<typename StringType>
1440 int KeyCompareWithValue(const StringType& _name) const {
1441 if (name()->c_str() < _name) return -1;
1442 if (_name < name()->c_str()) return 1;
1443 return 0;
1444 }
1445 const ::flatbuffers::Vector<uint8_t> *inventory() const {
1446 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1447 }
1448 ::flatbuffers::Vector<uint8_t> *mutable_inventory() {
1449 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1450 }
1451 MyGame::Example::Color color() const {
1452 return static_cast<MyGame::Example::Color>(GetField<uint8_t>(VT_COLOR, 8));
1453 }
1454 bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(8)) {
1455 return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 8);
1456 }
1457 MyGame::Example::Any test_type() const {
1458 return static_cast<MyGame::Example::Any>(GetField<uint8_t>(VT_TEST_TYPE, 0));
1459 }
1460 const void *test() const {
1461 return GetPointer<const void *>(VT_TEST);
1462 }
1463 template<typename T> const T *test_as() const;
1464 const MyGame::Example::Monster *test_as_Monster() const {
1465 return test_type() == MyGame::Example::Any::Monster ? static_cast<const MyGame::Example::Monster *>(test()) : nullptr;
1466 }
1467 const MyGame::Example::TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const {
1468 return test_type() == MyGame::Example::Any::TestSimpleTableWithEnum ? static_cast<const MyGame::Example::TestSimpleTableWithEnum *>(test()) : nullptr;
1469 }
1470 const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
1471 return test_type() == MyGame::Example::Any::MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
1472 }
1473 void *mutable_test() {
1474 return GetPointer<void *>(VT_TEST);
1475 }
1476 const ::flatbuffers::Vector<const MyGame::Example::Test *> *test4() const {
1477 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST4);
1478 }
1479 ::flatbuffers::Vector<const MyGame::Example::Test *> *mutable_test4() {
1480 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST4);
1481 }
1482 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring() const {
1483 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1484 }
1485 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_testarrayofstring() {
1486 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1487 }
1488 /// an example documentation comment: this will end up in the generated code
1489 /// multiline too
1490 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables() const {
1491 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *>(VT_TESTARRAYOFTABLES);
1492 }
1493 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *mutable_testarrayoftables() {
1494 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *>(VT_TESTARRAYOFTABLES);
1495 }
1496 const MyGame::Example::Monster *enemy() const {
1497 return GetPointer<const MyGame::Example::Monster *>(VT_ENEMY);
1498 }
1499 MyGame::Example::Monster *mutable_enemy() {
1500 return GetPointer<MyGame::Example::Monster *>(VT_ENEMY);
1501 }
1502 const ::flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const {
1503 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1504 }
1505 ::flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() {
1506 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1507 }
1508 const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const {
1509 const auto _f = testnestedflatbuffer();
1510 return _f ? ::flatbuffers::GetRoot<MyGame::Example::Monster>(_f->Data())
1511 : nullptr;
1512 }
1513 const MyGame::Example::Stat *testempty() const {
1514 return GetPointer<const MyGame::Example::Stat *>(VT_TESTEMPTY);
1515 }
1516 MyGame::Example::Stat *mutable_testempty() {
1517 return GetPointer<MyGame::Example::Stat *>(VT_TESTEMPTY);
1518 }
1519 bool testbool() const {
1520 return GetField<uint8_t>(VT_TESTBOOL, 0) != 0;
1521 }
1522 bool mutate_testbool(bool _testbool = 0) {
1523 return SetField<uint8_t>(VT_TESTBOOL, static_cast<uint8_t>(_testbool), 0);
1524 }
1525 int32_t testhashs32_fnv1() const {
1526 return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0);
1527 }
1528 bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1 = 0) {
1529 return SetField<int32_t>(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0);
1530 }
1531 uint32_t testhashu32_fnv1() const {
1532 return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0);
1533 }
1534 bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1 = 0) {
1535 return SetField<uint32_t>(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0);
1536 }
1537 int64_t testhashs64_fnv1() const {
1538 return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0);
1539 }
1540 bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1 = 0) {
1541 return SetField<int64_t>(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0);
1542 }
1543 uint64_t testhashu64_fnv1() const {
1544 return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0);
1545 }
1546 bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1 = 0) {
1547 return SetField<uint64_t>(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0);
1548 }
1549 int32_t testhashs32_fnv1a() const {
1550 return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0);
1551 }
1552 bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a = 0) {
1553 return SetField<int32_t>(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0);
1554 }
1555 uint32_t testhashu32_fnv1a() const {
1556 return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0);
1557 }
1558 bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a = 0) {
1559 return SetField<uint32_t>(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0);
1560 }
1561 int64_t testhashs64_fnv1a() const {
1562 return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0);
1563 }
1564 bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a = 0) {
1565 return SetField<int64_t>(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0);
1566 }
1567 uint64_t testhashu64_fnv1a() const {
1568 return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0);
1569 }
1570 bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a = 0) {
1571 return SetField<uint64_t>(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0);
1572 }
1573 const ::flatbuffers::Vector<uint8_t> *testarrayofbools() const {
1574 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1575 }
1576 ::flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() {
1577 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1578 }
1579 float testf() const {
1580 return GetField<float>(VT_TESTF, 3.14159f);
1581 }
1582 bool mutate_testf(float _testf = 3.14159f) {
1583 return SetField<float>(VT_TESTF, _testf, 3.14159f);
1584 }
1585 float testf2() const {
1586 return GetField<float>(VT_TESTF2, 3.0f);
1587 }
1588 bool mutate_testf2(float _testf2 = 3.0f) {
1589 return SetField<float>(VT_TESTF2, _testf2, 3.0f);
1590 }
1591 float testf3() const {
1592 return GetField<float>(VT_TESTF3, 0.0f);
1593 }
1594 bool mutate_testf3(float _testf3 = 0.0f) {
1595 return SetField<float>(VT_TESTF3, _testf3, 0.0f);
1596 }
1597 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2() const {
1598 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1599 }
1600 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_testarrayofstring2() {
1601 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1602 }
1603 const ::flatbuffers::Vector<const MyGame::Example::Ability *> *testarrayofsortedstruct() const {
1604 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1605 }
1606 ::flatbuffers::Vector<const MyGame::Example::Ability *> *mutable_testarrayofsortedstruct() {
1607 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1608 }
1609 const ::flatbuffers::Vector<uint8_t> *flex() const {
1610 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1611 }
1612 ::flatbuffers::Vector<uint8_t> *mutable_flex() {
1613 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1614 }
1615 flexbuffers::Reference flex_flexbuffer_root() const {
1616 const auto _f = flex();
1617 return _f ? flexbuffers::GetRoot(_f->Data(), _f->size())
1618 : flexbuffers::Reference();
1619 }
1620 const ::flatbuffers::Vector<const MyGame::Example::Test *> *test5() const {
1621 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST5);
1622 }
1623 ::flatbuffers::Vector<const MyGame::Example::Test *> *mutable_test5() {
1624 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST5);
1625 }
1626 const ::flatbuffers::Vector<int64_t> *vector_of_longs() const {
1627 return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1628 }
1629 ::flatbuffers::Vector<int64_t> *mutable_vector_of_longs() {
1630 return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1631 }
1632 const ::flatbuffers::Vector<double> *vector_of_doubles() const {
1633 return GetPointer<const ::flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1634 }
1635 ::flatbuffers::Vector<double> *mutable_vector_of_doubles() {
1636 return GetPointer<::flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1637 }
1638 const MyGame::InParentNamespace *parent_namespace_test() const {
1639 return GetPointer<const MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1640 }
1641 MyGame::InParentNamespace *mutable_parent_namespace_test() {
1642 return GetPointer<MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1643 }
1644 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables() const {
1645 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1646 }
1647 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *mutable_vector_of_referrables() {
1648 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1649 }
1650 uint64_t single_weak_reference() const {
1651 return GetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, 0);
1652 }
1653 bool mutate_single_weak_reference(uint64_t _single_weak_reference = 0) {
1654 return SetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0);
1655 }
1656 const ::flatbuffers::Vector<uint64_t> *vector_of_weak_references() const {
1657 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1658 }
1659 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_weak_references() {
1660 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1661 }
1662 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables() const {
1663 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1664 }
1665 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *mutable_vector_of_strong_referrables() {
1666 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1667 }
1668 uint64_t co_owning_reference() const {
1669 return GetField<uint64_t>(VT_CO_OWNING_REFERENCE, 0);
1670 }
1671 bool mutate_co_owning_reference(uint64_t _co_owning_reference = 0) {
1672 return SetField<uint64_t>(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0);
1673 }
1674 const ::flatbuffers::Vector<uint64_t> *vector_of_co_owning_references() const {
1675 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1676 }
1677 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_co_owning_references() {
1678 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1679 }
1680 uint64_t non_owning_reference() const {
1681 return GetField<uint64_t>(VT_NON_OWNING_REFERENCE, 0);
1682 }
1683 bool mutate_non_owning_reference(uint64_t _non_owning_reference = 0) {
1684 return SetField<uint64_t>(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0);
1685 }
1686 const ::flatbuffers::Vector<uint64_t> *vector_of_non_owning_references() const {
1687 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1688 }
1689 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_non_owning_references() {
1690 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1691 }
1692 MyGame::Example::AnyUniqueAliases any_unique_type() const {
1693 return static_cast<MyGame::Example::AnyUniqueAliases>(GetField<uint8_t>(VT_ANY_UNIQUE_TYPE, 0));
1694 }
1695 const void *any_unique() const {
1696 return GetPointer<const void *>(VT_ANY_UNIQUE);
1697 }
1698 template<typename T> const T *any_unique_as() const;
1699 const MyGame::Example::Monster *any_unique_as_M() const {
1700 return any_unique_type() == MyGame::Example::AnyUniqueAliases::M ? static_cast<const MyGame::Example::Monster *>(any_unique()) : nullptr;
1701 }
1702 const MyGame::Example::TestSimpleTableWithEnum *any_unique_as_TS() const {
1703 return any_unique_type() == MyGame::Example::AnyUniqueAliases::TS ? static_cast<const MyGame::Example::TestSimpleTableWithEnum *>(any_unique()) : nullptr;
1704 }
1705 const MyGame::Example2::Monster *any_unique_as_M2() const {
1706 return any_unique_type() == MyGame::Example::AnyUniqueAliases::M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
1707 }
1708 void *mutable_any_unique() {
1709 return GetPointer<void *>(VT_ANY_UNIQUE);
1710 }
1711 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const {
1712 return static_cast<MyGame::Example::AnyAmbiguousAliases>(GetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, 0));
1713 }
1714 const void *any_ambiguous() const {
1715 return GetPointer<const void *>(VT_ANY_AMBIGUOUS);
1716 }
1717 const MyGame::Example::Monster *any_ambiguous_as_M1() const {
1718 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M1 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1719 }
1720 const MyGame::Example::Monster *any_ambiguous_as_M2() const {
1721 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M2 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1722 }
1723 const MyGame::Example::Monster *any_ambiguous_as_M3() const {
1724 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1725 }
1726 void *mutable_any_ambiguous() {
1727 return GetPointer<void *>(VT_ANY_AMBIGUOUS);
1728 }
1729 const ::flatbuffers::Vector<MyGame::Example::Color> *vector_of_enums() const {
1730 return GetPointer<const ::flatbuffers::Vector<MyGame::Example::Color> *>(VT_VECTOR_OF_ENUMS);
1731 }
1732 ::flatbuffers::Vector<MyGame::Example::Color> *mutable_vector_of_enums() {
1733 return GetPointer<::flatbuffers::Vector<MyGame::Example::Color> *>(VT_VECTOR_OF_ENUMS);
1734 }
1735 MyGame::Example::Race signed_enum() const {
1736 return static_cast<MyGame::Example::Race>(GetField<int8_t>(VT_SIGNED_ENUM, -1));
1737 }
1738 bool mutate_signed_enum(MyGame::Example::Race _signed_enum = static_cast<MyGame::Example::Race>(-1)) {
1739 return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
1740 }
1741 const ::flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
1742 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
1743 }
1744 ::flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
1745 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
1746 }
1747 const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
1748 const auto _f = testrequirednestedflatbuffer();
1749 return _f ? ::flatbuffers::GetRoot<MyGame::Example::Monster>(_f->Data())
1750 : nullptr;
1751 }
1752 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables() const {
1753 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
1754 }
1755 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *mutable_scalar_key_sorted_tables() {
1756 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
1757 }
1758 const MyGame::Example::Test *native_inline() const {
1759 return GetStruct<const MyGame::Example::Test *>(VT_NATIVE_INLINE);
1760 }
1761 MyGame::Example::Test *mutable_native_inline() {
1762 return GetStruct<MyGame::Example::Test *>(VT_NATIVE_INLINE);
1763 }
1764 MyGame::Example::LongEnum long_enum_non_enum_default() const {
1765 return static_cast<MyGame::Example::LongEnum>(GetField<uint64_t>(VT_LONG_ENUM_NON_ENUM_DEFAULT, 0));
1766 }
1767 bool mutate_long_enum_non_enum_default(MyGame::Example::LongEnum _long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0)) {
1768 return SetField<uint64_t>(VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast<uint64_t>(_long_enum_non_enum_default), 0);
1769 }
1770 MyGame::Example::LongEnum long_enum_normal_default() const {
1771 return static_cast<MyGame::Example::LongEnum>(GetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, 2ULL));
1772 }
1773 bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
1774 return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
1775 }
1776 float nan_default() const {
1777 return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
1778 }
1779 bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
1780 return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
1781 }
1782 float inf_default() const {
1783 return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
1784 }
1785 bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
1786 return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
1787 }
1788 float positive_inf_default() const {
1789 return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
1790 }
1791 bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
1792 return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
1793 }
1794 float infinity_default() const {
1795 return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
1796 }
1797 bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
1798 return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
1799 }
1800 float positive_infinity_default() const {
1801 return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
1802 }
1803 bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
1804 return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
1805 }
1806 float negative_inf_default() const {
1807 return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
1808 }
1809 bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
1810 return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
1811 }
1812 float negative_infinity_default() const {
1813 return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
1814 }
1815 bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
1816 return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
1817 }
1818 double double_inf_default() const {
1819 return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
1820 }
1821 bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
1822 return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
1823 }
1824 template<size_t Index>
1825 auto get_field() const {
1826 if constexpr (Index == 0) return pos();
1827 else if constexpr (Index == 1) return mana();
1828 else if constexpr (Index == 2) return hp();
1829 else if constexpr (Index == 3) return name();
1830 else if constexpr (Index == 4) return inventory();
1831 else if constexpr (Index == 5) return color();
1832 else if constexpr (Index == 6) return test_type();
1833 else if constexpr (Index == 7) return test();
1834 else if constexpr (Index == 8) return test4();
1835 else if constexpr (Index == 9) return testarrayofstring();
1836 else if constexpr (Index == 10) return testarrayoftables();
1837 else if constexpr (Index == 11) return enemy();
1838 else if constexpr (Index == 12) return testnestedflatbuffer();
1839 else if constexpr (Index == 13) return testempty();
1840 else if constexpr (Index == 14) return testbool();
1841 else if constexpr (Index == 15) return testhashs32_fnv1();
1842 else if constexpr (Index == 16) return testhashu32_fnv1();
1843 else if constexpr (Index == 17) return testhashs64_fnv1();
1844 else if constexpr (Index == 18) return testhashu64_fnv1();
1845 else if constexpr (Index == 19) return testhashs32_fnv1a();
1846 else if constexpr (Index == 20) return testhashu32_fnv1a();
1847 else if constexpr (Index == 21) return testhashs64_fnv1a();
1848 else if constexpr (Index == 22) return testhashu64_fnv1a();
1849 else if constexpr (Index == 23) return testarrayofbools();
1850 else if constexpr (Index == 24) return testf();
1851 else if constexpr (Index == 25) return testf2();
1852 else if constexpr (Index == 26) return testf3();
1853 else if constexpr (Index == 27) return testarrayofstring2();
1854 else if constexpr (Index == 28) return testarrayofsortedstruct();
1855 else if constexpr (Index == 29) return flex();
1856 else if constexpr (Index == 30) return test5();
1857 else if constexpr (Index == 31) return vector_of_longs();
1858 else if constexpr (Index == 32) return vector_of_doubles();
1859 else if constexpr (Index == 33) return parent_namespace_test();
1860 else if constexpr (Index == 34) return vector_of_referrables();
1861 else if constexpr (Index == 35) return single_weak_reference();
1862 else if constexpr (Index == 36) return vector_of_weak_references();
1863 else if constexpr (Index == 37) return vector_of_strong_referrables();
1864 else if constexpr (Index == 38) return co_owning_reference();
1865 else if constexpr (Index == 39) return vector_of_co_owning_references();
1866 else if constexpr (Index == 40) return non_owning_reference();
1867 else if constexpr (Index == 41) return vector_of_non_owning_references();
1868 else if constexpr (Index == 42) return any_unique_type();
1869 else if constexpr (Index == 43) return any_unique();
1870 else if constexpr (Index == 44) return any_ambiguous_type();
1871 else if constexpr (Index == 45) return any_ambiguous();
1872 else if constexpr (Index == 46) return vector_of_enums();
1873 else if constexpr (Index == 47) return signed_enum();
1874 else if constexpr (Index == 48) return testrequirednestedflatbuffer();
1875 else if constexpr (Index == 49) return scalar_key_sorted_tables();
1876 else if constexpr (Index == 50) return native_inline();
1877 else if constexpr (Index == 51) return long_enum_non_enum_default();
1878 else if constexpr (Index == 52) return long_enum_normal_default();
1879 else if constexpr (Index == 53) return nan_default();
1880 else if constexpr (Index == 54) return inf_default();
1881 else if constexpr (Index == 55) return positive_inf_default();
1882 else if constexpr (Index == 56) return infinity_default();
1883 else if constexpr (Index == 57) return positive_infinity_default();
1884 else if constexpr (Index == 58) return negative_inf_default();
1885 else if constexpr (Index == 59) return negative_infinity_default();
1886 else if constexpr (Index == 60) return double_inf_default();
1887 else static_assert(Index != -1, "Invalid Field Index");
1888 }
1889 bool Verify(::flatbuffers::Verifier &verifier) const {
1890 return VerifyTableStart(verifier) &&
1891 VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
1892 VerifyField<int16_t>(verifier, VT_MANA, 2) &&
1893 VerifyField<int16_t>(verifier, VT_HP, 2) &&
1894 VerifyOffsetRequired(verifier, VT_NAME) &&
1895 verifier.VerifyString(name()) &&
1896 VerifyOffset(verifier, VT_INVENTORY) &&
1897 verifier.VerifyVector(inventory()) &&
1898 VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
1899 VerifyField<uint8_t>(verifier, VT_TEST_TYPE, 1) &&
1900 VerifyOffset(verifier, VT_TEST) &&
1901 VerifyAny(verifier, test(), test_type()) &&
1902 VerifyOffset(verifier, VT_TEST4) &&
1903 verifier.VerifyVector(test4()) &&
1904 VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
1905 verifier.VerifyVector(testarrayofstring()) &&
1906 verifier.VerifyVectorOfStrings(testarrayofstring()) &&
1907 VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
1908 verifier.VerifyVector(testarrayoftables()) &&
1909 verifier.VerifyVectorOfTables(testarrayoftables()) &&
1910 VerifyOffset(verifier, VT_ENEMY) &&
1911 verifier.VerifyTable(enemy()) &&
1912 VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
1913 verifier.VerifyVector(testnestedflatbuffer()) &&
1914 verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
1915 VerifyOffset(verifier, VT_TESTEMPTY) &&
1916 verifier.VerifyTable(testempty()) &&
1917 VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
1918 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1, 4) &&
1919 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1, 4) &&
1920 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1, 8) &&
1921 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1, 8) &&
1922 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A, 4) &&
1923 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A, 4) &&
1924 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A, 8) &&
1925 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A, 8) &&
1926 VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
1927 verifier.VerifyVector(testarrayofbools()) &&
1928 VerifyField<float>(verifier, VT_TESTF, 4) &&
1929 VerifyField<float>(verifier, VT_TESTF2, 4) &&
1930 VerifyField<float>(verifier, VT_TESTF3, 4) &&
1931 VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
1932 verifier.VerifyVector(testarrayofstring2()) &&
1933 verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
1934 VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
1935 verifier.VerifyVector(testarrayofsortedstruct()) &&
1936 VerifyOffset(verifier, VT_FLEX) &&
1937 verifier.VerifyVector(flex()) &&
1938 flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) &&
1939 VerifyOffset(verifier, VT_TEST5) &&
1940 verifier.VerifyVector(test5()) &&
1941 VerifyOffset(verifier, VT_VECTOR_OF_LONGS) &&
1942 verifier.VerifyVector(vector_of_longs()) &&
1943 VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) &&
1944 verifier.VerifyVector(vector_of_doubles()) &&
1945 VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
1946 verifier.VerifyTable(parent_namespace_test()) &&
1947 VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
1948 verifier.VerifyVector(vector_of_referrables()) &&
1949 verifier.VerifyVectorOfTables(vector_of_referrables()) &&
1950 VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE, 8) &&
1951 VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
1952 verifier.VerifyVector(vector_of_weak_references()) &&
1953 VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
1954 verifier.VerifyVector(vector_of_strong_referrables()) &&
1955 verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
1956 VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE, 8) &&
1957 VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
1958 verifier.VerifyVector(vector_of_co_owning_references()) &&
1959 VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE, 8) &&
1960 VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
1961 verifier.VerifyVector(vector_of_non_owning_references()) &&
1962 VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE, 1) &&
1963 VerifyOffset(verifier, VT_ANY_UNIQUE) &&
1964 VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
1965 VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) &&
1966 VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
1967 VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
1968 VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
1969 verifier.VerifyVector(vector_of_enums()) &&
1970 VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
1971 VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
1972 verifier.VerifyVector(testrequirednestedflatbuffer()) &&
1973 verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
1974 VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
1975 verifier.VerifyVector(scalar_key_sorted_tables()) &&
1976 verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
1977 VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
1978 VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
1979 VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
1980 VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
1981 VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
1982 VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
1983 VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
1984 VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
1985 VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
1986 VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
1987 VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
1988 verifier.EndTable();
1989 }
1990 MonsterT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1991 void UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1992 static ::flatbuffers::Offset<Monster> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1993 };
1994
1995 template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Example::Monster>() const {
1996 return test_as_Monster();
1997 }
1998
1999 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
2000 return test_as_TestSimpleTableWithEnum();
2001 }
2002
2003 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
2004 return test_as_MyGame_Example2_Monster();
2005 }
2006
2007 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
2008 return any_unique_as_M();
2009 }
2010
2011 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
2012 return any_unique_as_TS();
2013 }
2014
2015 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
2016 return any_unique_as_M2();
2017 }
2018
2019 struct MonsterBuilder {
2020 typedef Monster Table;
2021 ::flatbuffers::FlatBufferBuilder &fbb_;
2022 ::flatbuffers::uoffset_t start_;
2023 void add_pos(const MyGame::Example::Vec3 *pos) {
2024 fbb_.AddStruct(Monster::VT_POS, pos);
2025 }
2026 void add_mana(int16_t mana) {
2027 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
2028 }
2029 void add_hp(int16_t hp) {
2030 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
2031 }
2032 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
2033 fbb_.AddOffset(Monster::VT_NAME, name);
2034 }
2035 void add_inventory(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory) {
2036 fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
2037 }
2038 void add_color(MyGame::Example::Color color) {
2039 fbb_.AddElement<uint8_t>(Monster::VT_COLOR, static_cast<uint8_t>(color), 8);
2040 }
2041 void add_test_type(MyGame::Example::Any test_type) {
2042 fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0);
2043 }
2044 void add_test(::flatbuffers::Offset<void> test) {
2045 fbb_.AddOffset(Monster::VT_TEST, test);
2046 }
2047 void add_test4(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test4) {
2048 fbb_.AddOffset(Monster::VT_TEST4, test4);
2049 }
2050 void add_testarrayofstring(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring) {
2051 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring);
2052 }
2053 void add_testarrayoftables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>>> testarrayoftables) {
2054 fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables);
2055 }
2056 void add_enemy(::flatbuffers::Offset<MyGame::Example::Monster> enemy) {
2057 fbb_.AddOffset(Monster::VT_ENEMY, enemy);
2058 }
2059 void add_testnestedflatbuffer(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testnestedflatbuffer) {
2060 fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer);
2061 }
2062 void add_testempty(::flatbuffers::Offset<MyGame::Example::Stat> testempty) {
2063 fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty);
2064 }
2065 void add_testbool(bool testbool) {
2066 fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0);
2067 }
2068 void add_testhashs32_fnv1(int32_t testhashs32_fnv1) {
2069 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0);
2070 }
2071 void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) {
2072 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0);
2073 }
2074 void add_testhashs64_fnv1(int64_t testhashs64_fnv1) {
2075 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0);
2076 }
2077 void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) {
2078 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0);
2079 }
2080 void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) {
2081 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0);
2082 }
2083 void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) {
2084 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0);
2085 }
2086 void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) {
2087 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0);
2088 }
2089 void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) {
2090 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0);
2091 }
2092 void add_testarrayofbools(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testarrayofbools) {
2093 fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools);
2094 }
2095 void add_testf(float testf) {
2096 fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f);
2097 }
2098 void add_testf2(float testf2) {
2099 fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f);
2100 }
2101 void add_testf3(float testf3) {
2102 fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f);
2103 }
2104 void add_testarrayofstring2(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring2) {
2105 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2);
2106 }
2107 void add_testarrayofsortedstruct(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Ability *>> testarrayofsortedstruct) {
2108 fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct);
2109 }
2110 void add_flex(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> flex) {
2111 fbb_.AddOffset(Monster::VT_FLEX, flex);
2112 }
2113 void add_test5(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test5) {
2114 fbb_.AddOffset(Monster::VT_TEST5, test5);
2115 }
2116 void add_vector_of_longs(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> vector_of_longs) {
2117 fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs);
2118 }
2119 void add_vector_of_doubles(::flatbuffers::Offset<::flatbuffers::Vector<double>> vector_of_doubles) {
2120 fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles);
2121 }
2122 void add_parent_namespace_test(::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test) {
2123 fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test);
2124 }
2125 void add_vector_of_referrables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_referrables) {
2126 fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables);
2127 }
2128 void add_single_weak_reference(uint64_t single_weak_reference) {
2129 fbb_.AddElement<uint64_t>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0);
2130 }
2131 void add_vector_of_weak_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_weak_references) {
2132 fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references);
2133 }
2134 void add_vector_of_strong_referrables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_strong_referrables) {
2135 fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables);
2136 }
2137 void add_co_owning_reference(uint64_t co_owning_reference) {
2138 fbb_.AddElement<uint64_t>(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0);
2139 }
2140 void add_vector_of_co_owning_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_co_owning_references) {
2141 fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references);
2142 }
2143 void add_non_owning_reference(uint64_t non_owning_reference) {
2144 fbb_.AddElement<uint64_t>(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0);
2145 }
2146 void add_vector_of_non_owning_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_non_owning_references) {
2147 fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references);
2148 }
2149 void add_any_unique_type(MyGame::Example::AnyUniqueAliases any_unique_type) {
2150 fbb_.AddElement<uint8_t>(Monster::VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(any_unique_type), 0);
2151 }
2152 void add_any_unique(::flatbuffers::Offset<void> any_unique) {
2153 fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique);
2154 }
2155 void add_any_ambiguous_type(MyGame::Example::AnyAmbiguousAliases any_ambiguous_type) {
2156 fbb_.AddElement<uint8_t>(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(any_ambiguous_type), 0);
2157 }
2158 void add_any_ambiguous(::flatbuffers::Offset<void> any_ambiguous) {
2159 fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
2160 }
2161 void add_vector_of_enums(::flatbuffers::Offset<::flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums) {
2162 fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
2163 }
2164 void add_signed_enum(MyGame::Example::Race signed_enum) {
2165 fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
2166 }
2167 void add_testrequirednestedflatbuffer(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
2168 fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
2169 }
2170 void add_scalar_key_sorted_tables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables) {
2171 fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
2172 }
2173 void add_native_inline(const MyGame::Example::Test *native_inline) {
2174 fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline);
2175 }
2176 void add_long_enum_non_enum_default(MyGame::Example::LongEnum long_enum_non_enum_default) {
2177 fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast<uint64_t>(long_enum_non_enum_default), 0);
2178 }
2179 void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
2180 fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
2181 }
2182 void add_nan_default(float nan_default) {
2183 fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
2184 }
2185 void add_inf_default(float inf_default) {
2186 fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
2187 }
2188 void add_positive_inf_default(float positive_inf_default) {
2189 fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
2190 }
2191 void add_infinity_default(float infinity_default) {
2192 fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
2193 }
2194 void add_positive_infinity_default(float positive_infinity_default) {
2195 fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
2196 }
2197 void add_negative_inf_default(float negative_inf_default) {
2198 fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
2199 }
2200 void add_negative_infinity_default(float negative_infinity_default) {
2201 fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
2202 }
2203 void add_double_inf_default(double double_inf_default) {
2204 fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
2205 }
2206 explicit MonsterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2207 : fbb_(_fbb) {
2208 start_ = fbb_.StartTable();
2209 }
2210 ::flatbuffers::Offset<Monster> Finish() {
2211 const auto end = fbb_.EndTable(start_);
2212 auto o = ::flatbuffers::Offset<Monster>(end);
2213 fbb_.Required(o, Monster::VT_NAME);
2214 return o;
2215 }
2216 };
2217
2218 inline ::flatbuffers::Offset<Monster> CreateMonster(
2219 ::flatbuffers::FlatBufferBuilder &_fbb,
2220 const MyGame::Example::Vec3 *pos = nullptr,
2221 int16_t mana = 150,
2222 int16_t hp = 100,
2223 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
2224 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory = 0,
2225 MyGame::Example::Color color = MyGame::Example::Color::Blue,
2226 MyGame::Example::Any test_type = MyGame::Example::Any::NONE,
2227 ::flatbuffers::Offset<void> test = 0,
2228 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test4 = 0,
2229 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring = 0,
2230 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>>> testarrayoftables = 0,
2231 ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
2232 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
2233 ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
2234 bool testbool = false,
2235 int32_t testhashs32_fnv1 = 0,
2236 uint32_t testhashu32_fnv1 = 0,
2237 int64_t testhashs64_fnv1 = 0,
2238 uint64_t testhashu64_fnv1 = 0,
2239 int32_t testhashs32_fnv1a = 0,
2240 uint32_t testhashu32_fnv1a = 0,
2241 int64_t testhashs64_fnv1a = 0,
2242 uint64_t testhashu64_fnv1a = 0,
2243 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testarrayofbools = 0,
2244 float testf = 3.14159f,
2245 float testf2 = 3.0f,
2246 float testf3 = 0.0f,
2247 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring2 = 0,
2248 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Ability *>> testarrayofsortedstruct = 0,
2249 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> flex = 0,
2250 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test5 = 0,
2251 ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> vector_of_longs = 0,
2252 ::flatbuffers::Offset<::flatbuffers::Vector<double>> vector_of_doubles = 0,
2253 ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
2254 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_referrables = 0,
2255 uint64_t single_weak_reference = 0,
2256 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0,
2257 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_strong_referrables = 0,
2258 uint64_t co_owning_reference = 0,
2259 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_co_owning_references = 0,
2260 uint64_t non_owning_reference = 0,
2261 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_non_owning_references = 0,
2262 MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases::NONE,
2263 ::flatbuffers::Offset<void> any_unique = 0,
2264 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
2265 ::flatbuffers::Offset<void> any_ambiguous = 0,
2266 ::flatbuffers::Offset<::flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums = 0,
2267 MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
2268 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0,
2269 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
2270 const MyGame::Example::Test *native_inline = nullptr,
2271 MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
2272 MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
2273 float nan_default = std::numeric_limits<float>::quiet_NaN(),
2274 float inf_default = std::numeric_limits<float>::infinity(),
2275 float positive_inf_default = std::numeric_limits<float>::infinity(),
2276 float infinity_default = std::numeric_limits<float>::infinity(),
2277 float positive_infinity_default = std::numeric_limits<float>::infinity(),
2278 float negative_inf_default = -std::numeric_limits<float>::infinity(),
2279 float negative_infinity_default = -std::numeric_limits<float>::infinity(),
2280 double double_inf_default = std::numeric_limits<double>::infinity()) {
2281 MonsterBuilder builder_(_fbb);
2282 builder_.add_double_inf_default(double_inf_default);
2283 builder_.add_long_enum_normal_default(long_enum_normal_default);
2284 builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
2285 builder_.add_non_owning_reference(non_owning_reference);
2286 builder_.add_co_owning_reference(co_owning_reference);
2287 builder_.add_single_weak_reference(single_weak_reference);
2288 builder_.add_testhashu64_fnv1a(testhashu64_fnv1a);
2289 builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
2290 builder_.add_testhashu64_fnv1(testhashu64_fnv1);
2291 builder_.add_testhashs64_fnv1(testhashs64_fnv1);
2292 builder_.add_negative_infinity_default(negative_infinity_default);
2293 builder_.add_negative_inf_default(negative_inf_default);
2294 builder_.add_positive_infinity_default(positive_infinity_default);
2295 builder_.add_infinity_default(infinity_default);
2296 builder_.add_positive_inf_default(positive_inf_default);
2297 builder_.add_inf_default(inf_default);
2298 builder_.add_nan_default(nan_default);
2299 builder_.add_native_inline(native_inline);
2300 builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
2301 builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
2302 builder_.add_vector_of_enums(vector_of_enums);
2303 builder_.add_any_ambiguous(any_ambiguous);
2304 builder_.add_any_unique(any_unique);
2305 builder_.add_vector_of_non_owning_references(vector_of_non_owning_references);
2306 builder_.add_vector_of_co_owning_references(vector_of_co_owning_references);
2307 builder_.add_vector_of_strong_referrables(vector_of_strong_referrables);
2308 builder_.add_vector_of_weak_references(vector_of_weak_references);
2309 builder_.add_vector_of_referrables(vector_of_referrables);
2310 builder_.add_parent_namespace_test(parent_namespace_test);
2311 builder_.add_vector_of_doubles(vector_of_doubles);
2312 builder_.add_vector_of_longs(vector_of_longs);
2313 builder_.add_test5(test5);
2314 builder_.add_flex(flex);
2315 builder_.add_testarrayofsortedstruct(testarrayofsortedstruct);
2316 builder_.add_testarrayofstring2(testarrayofstring2);
2317 builder_.add_testf3(testf3);
2318 builder_.add_testf2(testf2);
2319 builder_.add_testf(testf);
2320 builder_.add_testarrayofbools(testarrayofbools);
2321 builder_.add_testhashu32_fnv1a(testhashu32_fnv1a);
2322 builder_.add_testhashs32_fnv1a(testhashs32_fnv1a);
2323 builder_.add_testhashu32_fnv1(testhashu32_fnv1);
2324 builder_.add_testhashs32_fnv1(testhashs32_fnv1);
2325 builder_.add_testempty(testempty);
2326 builder_.add_testnestedflatbuffer(testnestedflatbuffer);
2327 builder_.add_enemy(enemy);
2328 builder_.add_testarrayoftables(testarrayoftables);
2329 builder_.add_testarrayofstring(testarrayofstring);
2330 builder_.add_test4(test4);
2331 builder_.add_test(test);
2332 builder_.add_inventory(inventory);
2333 builder_.add_name(name);
2334 builder_.add_pos(pos);
2335 builder_.add_hp(hp);
2336 builder_.add_mana(mana);
2337 builder_.add_signed_enum(signed_enum);
2338 builder_.add_any_ambiguous_type(any_ambiguous_type);
2339 builder_.add_any_unique_type(any_unique_type);
2340 builder_.add_testbool(testbool);
2341 builder_.add_test_type(test_type);
2342 builder_.add_color(color);
2343 return builder_.Finish();
2344 }
2345
2346 struct Monster::Traits {
2347 using type = Monster;
2348 static auto constexpr Create = CreateMonster;
2349 static constexpr auto name = "Monster";
2350 static constexpr auto fully_qualified_name = "MyGame.Example.Monster";
2351 static constexpr size_t fields_number = 61;
2352 static constexpr std::array<const char *, fields_number> field_names = {
2353 "pos",
2354 "mana",
2355 "hp",
2356 "name",
2357 "inventory",
2358 "color",
2359 "test_type",
2360 "test",
2361 "test4",
2362 "testarrayofstring",
2363 "testarrayoftables",
2364 "enemy",
2365 "testnestedflatbuffer",
2366 "testempty",
2367 "testbool",
2368 "testhashs32_fnv1",
2369 "testhashu32_fnv1",
2370 "testhashs64_fnv1",
2371 "testhashu64_fnv1",
2372 "testhashs32_fnv1a",
2373 "testhashu32_fnv1a",
2374 "testhashs64_fnv1a",
2375 "testhashu64_fnv1a",
2376 "testarrayofbools",
2377 "testf",
2378 "testf2",
2379 "testf3",
2380 "testarrayofstring2",
2381 "testarrayofsortedstruct",
2382 "flex",
2383 "test5",
2384 "vector_of_longs",
2385 "vector_of_doubles",
2386 "parent_namespace_test",
2387 "vector_of_referrables",
2388 "single_weak_reference",
2389 "vector_of_weak_references",
2390 "vector_of_strong_referrables",
2391 "co_owning_reference",
2392 "vector_of_co_owning_references",
2393 "non_owning_reference",
2394 "vector_of_non_owning_references",
2395 "any_unique_type",
2396 "any_unique",
2397 "any_ambiguous_type",
2398 "any_ambiguous",
2399 "vector_of_enums",
2400 "signed_enum",
2401 "testrequirednestedflatbuffer",
2402 "scalar_key_sorted_tables",
2403 "native_inline",
2404 "long_enum_non_enum_default",
2405 "long_enum_normal_default",
2406 "nan_default",
2407 "inf_default",
2408 "positive_inf_default",
2409 "infinity_default",
2410 "positive_infinity_default",
2411 "negative_inf_default",
2412 "negative_infinity_default",
2413 "double_inf_default"
2414 };
2415 template<size_t Index>
2416 using FieldType = decltype(std::declval<type>().get_field<Index>());
2417 };
2418
2419 inline ::flatbuffers::Offset<Monster> CreateMonsterDirect(
2420 ::flatbuffers::FlatBufferBuilder &_fbb,
2421 const MyGame::Example::Vec3 *pos = nullptr,
2422 int16_t mana = 150,
2423 int16_t hp = 100,
2424 const char *name = nullptr,
2425 const std::vector<uint8_t> *inventory = nullptr,
2426 MyGame::Example::Color color = MyGame::Example::Color::Blue,
2427 MyGame::Example::Any test_type = MyGame::Example::Any::NONE,
2428 ::flatbuffers::Offset<void> test = 0,
2429 const std::vector<MyGame::Example::Test> *test4 = nullptr,
2430 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring = nullptr,
2431 std::vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables = nullptr,
2432 ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
2433 const std::vector<uint8_t> *testnestedflatbuffer = nullptr,
2434 ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
2435 bool testbool = false,
2436 int32_t testhashs32_fnv1 = 0,
2437 uint32_t testhashu32_fnv1 = 0,
2438 int64_t testhashs64_fnv1 = 0,
2439 uint64_t testhashu64_fnv1 = 0,
2440 int32_t testhashs32_fnv1a = 0,
2441 uint32_t testhashu32_fnv1a = 0,
2442 int64_t testhashs64_fnv1a = 0,
2443 uint64_t testhashu64_fnv1a = 0,
2444 const std::vector<uint8_t> *testarrayofbools = nullptr,
2445 float testf = 3.14159f,
2446 float testf2 = 3.0f,
2447 float testf3 = 0.0f,
2448 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2 = nullptr,
2449 std::vector<MyGame::Example::Ability> *testarrayofsortedstruct = nullptr,
2450 const std::vector<uint8_t> *flex = nullptr,
2451 const std::vector<MyGame::Example::Test> *test5 = nullptr,
2452 const std::vector<int64_t> *vector_of_longs = nullptr,
2453 const std::vector<double> *vector_of_doubles = nullptr,
2454 ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
2455 std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables = nullptr,
2456 uint64_t single_weak_reference = 0,
2457 const std::vector<uint64_t> *vector_of_weak_references = nullptr,
2458 std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables = nullptr,
2459 uint64_t co_owning_reference = 0,
2460 const std::vector<uint64_t> *vector_of_co_owning_references = nullptr,
2461 uint64_t non_owning_reference = 0,
2462 const std::vector<uint64_t> *vector_of_non_owning_references = nullptr,
2463 MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases::NONE,
2464 ::flatbuffers::Offset<void> any_unique = 0,
2465 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
2466 ::flatbuffers::Offset<void> any_ambiguous = 0,
2467 const std::vector<MyGame::Example::Color> *vector_of_enums = nullptr,
2468 MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
2469 const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr,
2470 std::vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
2471 const MyGame::Example::Test *native_inline = nullptr,
2472 MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
2473 MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
2474 float nan_default = std::numeric_limits<float>::quiet_NaN(),
2475 float inf_default = std::numeric_limits<float>::infinity(),
2476 float positive_inf_default = std::numeric_limits<float>::infinity(),
2477 float infinity_default = std::numeric_limits<float>::infinity(),
2478 float positive_infinity_default = std::numeric_limits<float>::infinity(),
2479 float negative_inf_default = -std::numeric_limits<float>::infinity(),
2480 float negative_infinity_default = -std::numeric_limits<float>::infinity(),
2481 double double_inf_default = std::numeric_limits<double>::infinity()) {
2482 auto name__ = name ? _fbb.CreateString(name) : 0;
2483 auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
2484 auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
2485 auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*testarrayofstring) : 0;
2486 auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Monster>(testarrayoftables) : 0;
2487 auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0;
2488 auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0;
2489 auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*testarrayofstring2) : 0;
2490 auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfSortedStructs<MyGame::Example::Ability>(testarrayofsortedstruct) : 0;
2491 auto flex__ = flex ? _fbb.CreateVector<uint8_t>(*flex) : 0;
2492 auto test5__ = test5 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test5) : 0;
2493 auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector<int64_t>(*vector_of_longs) : 0;
2494 auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector<double>(*vector_of_doubles) : 0;
2495 auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Referrable>(vector_of_referrables) : 0;
2496 auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector<uint64_t>(*vector_of_weak_references) : 0;
2497 auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Referrable>(vector_of_strong_referrables) : 0;
2498 auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
2499 auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
2500 auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<MyGame::Example::Color>(*vector_of_enums) : 0;
2501 auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
2502 auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Stat>(scalar_key_sorted_tables) : 0;
2503 return MyGame::Example::CreateMonster(
2504 _fbb,
2505 pos,
2506 mana,
2507 hp,
2508 name__,
2509 inventory__,
2510 color,
2511 test_type,
2512 test,
2513 test4__,
2514 testarrayofstring__,
2515 testarrayoftables__,
2516 enemy,
2517 testnestedflatbuffer__,
2518 testempty,
2519 testbool,
2520 testhashs32_fnv1,
2521 testhashu32_fnv1,
2522 testhashs64_fnv1,
2523 testhashu64_fnv1,
2524 testhashs32_fnv1a,
2525 testhashu32_fnv1a,
2526 testhashs64_fnv1a,
2527 testhashu64_fnv1a,
2528 testarrayofbools__,
2529 testf,
2530 testf2,
2531 testf3,
2532 testarrayofstring2__,
2533 testarrayofsortedstruct__,
2534 flex__,
2535 test5__,
2536 vector_of_longs__,
2537 vector_of_doubles__,
2538 parent_namespace_test,
2539 vector_of_referrables__,
2540 single_weak_reference,
2541 vector_of_weak_references__,
2542 vector_of_strong_referrables__,
2543 co_owning_reference,
2544 vector_of_co_owning_references__,
2545 non_owning_reference,
2546 vector_of_non_owning_references__,
2547 any_unique_type,
2548 any_unique,
2549 any_ambiguous_type,
2550 any_ambiguous,
2551 vector_of_enums__,
2552 signed_enum,
2553 testrequirednestedflatbuffer__,
2554 scalar_key_sorted_tables__,
2555 native_inline,
2556 long_enum_non_enum_default,
2557 long_enum_normal_default,
2558 nan_default,
2559 inf_default,
2560 positive_inf_default,
2561 infinity_default,
2562 positive_infinity_default,
2563 negative_inf_default,
2564 negative_infinity_default,
2565 double_inf_default);
2566 }
2567
2568 ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2569
2570 struct TypeAliasesT : public ::flatbuffers::NativeTable {
2571 typedef TypeAliases TableType;
2572 int8_t i8 = 0;
2573 uint8_t u8 = 0;
2574 int16_t i16 = 0;
2575 uint16_t u16 = 0;
2576 int32_t i32 = 0;
2577 uint32_t u32 = 0;
2578 int64_t i64 = 0;
2579 uint64_t u64 = 0;
2580 float f32 = 0.0f;
2581 double f64 = 0.0;
2582 std::vector<int8_t> v8{};
2583 std::vector<double> vf64{};
2584 };
2585
2586 struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
2587 typedef TypeAliasesT NativeTableType;
2588 typedef TypeAliasesBuilder Builder;
2589 struct Traits;
2590 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
2591 return TypeAliasesTypeTable();
2592 }
2593 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2594 VT_I8 = 4,
2595 VT_U8 = 6,
2596 VT_I16 = 8,
2597 VT_U16 = 10,
2598 VT_I32 = 12,
2599 VT_U32 = 14,
2600 VT_I64 = 16,
2601 VT_U64 = 18,
2602 VT_F32 = 20,
2603 VT_F64 = 22,
2604 VT_V8 = 24,
2605 VT_VF64 = 26
2606 };
2607 int8_t i8() const {
2608 return GetField<int8_t>(VT_I8, 0);
2609 }
2610 bool mutate_i8(int8_t _i8 = 0) {
2611 return SetField<int8_t>(VT_I8, _i8, 0);
2612 }
2613 uint8_t u8() const {
2614 return GetField<uint8_t>(VT_U8, 0);
2615 }
2616 bool mutate_u8(uint8_t _u8 = 0) {
2617 return SetField<uint8_t>(VT_U8, _u8, 0);
2618 }
2619 int16_t i16() const {
2620 return GetField<int16_t>(VT_I16, 0);
2621 }
2622 bool mutate_i16(int16_t _i16 = 0) {
2623 return SetField<int16_t>(VT_I16, _i16, 0);
2624 }
2625 uint16_t u16() const {
2626 return GetField<uint16_t>(VT_U16, 0);
2627 }
2628 bool mutate_u16(uint16_t _u16 = 0) {
2629 return SetField<uint16_t>(VT_U16, _u16, 0);
2630 }
2631 int32_t i32() const {
2632 return GetField<int32_t>(VT_I32, 0);
2633 }
2634 bool mutate_i32(int32_t _i32 = 0) {
2635 return SetField<int32_t>(VT_I32, _i32, 0);
2636 }
2637 uint32_t u32() const {
2638 return GetField<uint32_t>(VT_U32, 0);
2639 }
2640 bool mutate_u32(uint32_t _u32 = 0) {
2641 return SetField<uint32_t>(VT_U32, _u32, 0);
2642 }
2643 int64_t i64() const {
2644 return GetField<int64_t>(VT_I64, 0);
2645 }
2646 bool mutate_i64(int64_t _i64 = 0) {
2647 return SetField<int64_t>(VT_I64, _i64, 0);
2648 }
2649 uint64_t u64() const {
2650 return GetField<uint64_t>(VT_U64, 0);
2651 }
2652 bool mutate_u64(uint64_t _u64 = 0) {
2653 return SetField<uint64_t>(VT_U64, _u64, 0);
2654 }
2655 float f32() const {
2656 return GetField<float>(VT_F32, 0.0f);
2657 }
2658 bool mutate_f32(float _f32 = 0.0f) {
2659 return SetField<float>(VT_F32, _f32, 0.0f);
2660 }
2661 double f64() const {
2662 return GetField<double>(VT_F64, 0.0);
2663 }
2664 bool mutate_f64(double _f64 = 0.0) {
2665 return SetField<double>(VT_F64, _f64, 0.0);
2666 }
2667 const ::flatbuffers::Vector<int8_t> *v8() const {
2668 return GetPointer<const ::flatbuffers::Vector<int8_t> *>(VT_V8);
2669 }
2670 ::flatbuffers::Vector<int8_t> *mutable_v8() {
2671 return GetPointer<::flatbuffers::Vector<int8_t> *>(VT_V8);
2672 }
2673 const ::flatbuffers::Vector<double> *vf64() const {
2674 return GetPointer<const ::flatbuffers::Vector<double> *>(VT_VF64);
2675 }
2676 ::flatbuffers::Vector<double> *mutable_vf64() {
2677 return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
2678 }
2679 template<size_t Index>
2680 auto get_field() const {
2681 if constexpr (Index == 0) return i8();
2682 else if constexpr (Index == 1) return u8();
2683 else if constexpr (Index == 2) return i16();
2684 else if constexpr (Index == 3) return u16();
2685 else if constexpr (Index == 4) return i32();
2686 else if constexpr (Index == 5) return u32();
2687 else if constexpr (Index == 6) return i64();
2688 else if constexpr (Index == 7) return u64();
2689 else if constexpr (Index == 8) return f32();
2690 else if constexpr (Index == 9) return f64();
2691 else if constexpr (Index == 10) return v8();
2692 else if constexpr (Index == 11) return vf64();
2693 else static_assert(Index != -1, "Invalid Field Index");
2694 }
2695 bool Verify(::flatbuffers::Verifier &verifier) const {
2696 return VerifyTableStart(verifier) &&
2697 VerifyField<int8_t>(verifier, VT_I8, 1) &&
2698 VerifyField<uint8_t>(verifier, VT_U8, 1) &&
2699 VerifyField<int16_t>(verifier, VT_I16, 2) &&
2700 VerifyField<uint16_t>(verifier, VT_U16, 2) &&
2701 VerifyField<int32_t>(verifier, VT_I32, 4) &&
2702 VerifyField<uint32_t>(verifier, VT_U32, 4) &&
2703 VerifyField<int64_t>(verifier, VT_I64, 8) &&
2704 VerifyField<uint64_t>(verifier, VT_U64, 8) &&
2705 VerifyField<float>(verifier, VT_F32, 4) &&
2706 VerifyField<double>(verifier, VT_F64, 8) &&
2707 VerifyOffset(verifier, VT_V8) &&
2708 verifier.VerifyVector(v8()) &&
2709 VerifyOffset(verifier, VT_VF64) &&
2710 verifier.VerifyVector(vf64()) &&
2711 verifier.EndTable();
2712 }
2713 TypeAliasesT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
2714 void UnPackTo(TypeAliasesT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
2715 static ::flatbuffers::Offset<TypeAliases> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2716 };
2717
2718 struct TypeAliasesBuilder {
2719 typedef TypeAliases Table;
2720 ::flatbuffers::FlatBufferBuilder &fbb_;
2721 ::flatbuffers::uoffset_t start_;
2722 void add_i8(int8_t i8) {
2723 fbb_.AddElement<int8_t>(TypeAliases::VT_I8, i8, 0);
2724 }
2725 void add_u8(uint8_t u8) {
2726 fbb_.AddElement<uint8_t>(TypeAliases::VT_U8, u8, 0);
2727 }
2728 void add_i16(int16_t i16) {
2729 fbb_.AddElement<int16_t>(TypeAliases::VT_I16, i16, 0);
2730 }
2731 void add_u16(uint16_t u16) {
2732 fbb_.AddElement<uint16_t>(TypeAliases::VT_U16, u16, 0);
2733 }
2734 void add_i32(int32_t i32) {
2735 fbb_.AddElement<int32_t>(TypeAliases::VT_I32, i32, 0);
2736 }
2737 void add_u32(uint32_t u32) {
2738 fbb_.AddElement<uint32_t>(TypeAliases::VT_U32, u32, 0);
2739 }
2740 void add_i64(int64_t i64) {
2741 fbb_.AddElement<int64_t>(TypeAliases::VT_I64, i64, 0);
2742 }
2743 void add_u64(uint64_t u64) {
2744 fbb_.AddElement<uint64_t>(TypeAliases::VT_U64, u64, 0);
2745 }
2746 void add_f32(float f32) {
2747 fbb_.AddElement<float>(TypeAliases::VT_F32, f32, 0.0f);
2748 }
2749 void add_f64(double f64) {
2750 fbb_.AddElement<double>(TypeAliases::VT_F64, f64, 0.0);
2751 }
2752 void add_v8(::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> v8) {
2753 fbb_.AddOffset(TypeAliases::VT_V8, v8);
2754 }
2755 void add_vf64(::flatbuffers::Offset<::flatbuffers::Vector<double>> vf64) {
2756 fbb_.AddOffset(TypeAliases::VT_VF64, vf64);
2757 }
2758 explicit TypeAliasesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2759 : fbb_(_fbb) {
2760 start_ = fbb_.StartTable();
2761 }
2762 ::flatbuffers::Offset<TypeAliases> Finish() {
2763 const auto end = fbb_.EndTable(start_);
2764 auto o = ::flatbuffers::Offset<TypeAliases>(end);
2765 return o;
2766 }
2767 };
2768
2769 inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(
2770 ::flatbuffers::FlatBufferBuilder &_fbb,
2771 int8_t i8 = 0,
2772 uint8_t u8 = 0,
2773 int16_t i16 = 0,
2774 uint16_t u16 = 0,
2775 int32_t i32 = 0,
2776 uint32_t u32 = 0,
2777 int64_t i64 = 0,
2778 uint64_t u64 = 0,
2779 float f32 = 0.0f,
2780 double f64 = 0.0,
2781 ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> v8 = 0,
2782 ::flatbuffers::Offset<::flatbuffers::Vector<double>> vf64 = 0) {
2783 TypeAliasesBuilder builder_(_fbb);
2784 builder_.add_f64(f64);
2785 builder_.add_u64(u64);
2786 builder_.add_i64(i64);
2787 builder_.add_vf64(vf64);
2788 builder_.add_v8(v8);
2789 builder_.add_f32(f32);
2790 builder_.add_u32(u32);
2791 builder_.add_i32(i32);
2792 builder_.add_u16(u16);
2793 builder_.add_i16(i16);
2794 builder_.add_u8(u8);
2795 builder_.add_i8(i8);
2796 return builder_.Finish();
2797 }
2798
2799 struct TypeAliases::Traits {
2800 using type = TypeAliases;
2801 static auto constexpr Create = CreateTypeAliases;
2802 static constexpr auto name = "TypeAliases";
2803 static constexpr auto fully_qualified_name = "MyGame.Example.TypeAliases";
2804 static constexpr size_t fields_number = 12;
2805 static constexpr std::array<const char *, fields_number> field_names = {
2806 "i8",
2807 "u8",
2808 "i16",
2809 "u16",
2810 "i32",
2811 "u32",
2812 "i64",
2813 "u64",
2814 "f32",
2815 "f64",
2816 "v8",
2817 "vf64"
2818 };
2819 template<size_t Index>
2820 using FieldType = decltype(std::declval<type>().get_field<Index>());
2821 };
2822
2823 inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliasesDirect(
2824 ::flatbuffers::FlatBufferBuilder &_fbb,
2825 int8_t i8 = 0,
2826 uint8_t u8 = 0,
2827 int16_t i16 = 0,
2828 uint16_t u16 = 0,
2829 int32_t i32 = 0,
2830 uint32_t u32 = 0,
2831 int64_t i64 = 0,
2832 uint64_t u64 = 0,
2833 float f32 = 0.0f,
2834 double f64 = 0.0,
2835 const std::vector<int8_t> *v8 = nullptr,
2836 const std::vector<double> *vf64 = nullptr) {
2837 auto v8__ = v8 ? _fbb.CreateVector<int8_t>(*v8) : 0;
2838 auto vf64__ = vf64 ? _fbb.CreateVector<double>(*vf64) : 0;
2839 return MyGame::Example::CreateTypeAliases(
2840 _fbb,
2841 i8,
2842 u8,
2843 i16,
2844 u16,
2845 i32,
2846 u32,
2847 i64,
2848 u64,
2849 f32,
2850 f64,
2851 v8__,
2852 vf64__);
2853 }
2854
2855 ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2856
2857 } // namespace Example
2858
2859 inline InParentNamespaceT *InParentNamespace::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2860 auto _o = std::make_unique<InParentNamespaceT>();
2861 UnPackTo(_o.get(), _resolver);
2862 return _o.release();
2863 }
2864
2865 inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2866 (void)_o;
2867 (void)_resolver;
2868 }
2869
2870 inline ::flatbuffers::Offset<InParentNamespace> InParentNamespace::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2871 return CreateInParentNamespace(_fbb, _o, _rehasher);
2872 }
2873
2874 inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2875 (void)_rehasher;
2876 (void)_o;
2877 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2878 return MyGame::CreateInParentNamespace(
2879 _fbb);
2880 }
2881
2882 namespace Example2 {
2883
2884 inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2885 auto _o = std::make_unique<MonsterT>();
2886 UnPackTo(_o.get(), _resolver);
2887 return _o.release();
2888 }
2889
2890 inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2891 (void)_o;
2892 (void)_resolver;
2893 }
2894
2895 inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2896 return CreateMonster(_fbb, _o, _rehasher);
2897 }
2898
2899 inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2900 (void)_rehasher;
2901 (void)_o;
2902 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2903 return MyGame::Example2::CreateMonster(
2904 _fbb);
2905 }
2906
2907 } // namespace Example2
2908
2909 namespace Example {
2910
2911 inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2912 auto _o = std::make_unique<TestSimpleTableWithEnumT>();
2913 UnPackTo(_o.get(), _resolver);
2914 return _o.release();
2915 }
2916
2917 inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2918 (void)_o;
2919 (void)_resolver;
2920 { auto _e = color(); _o->color = _e; }
2921 }
2922
2923 inline ::flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2924 return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher);
2925 }
2926
2927 inline ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2928 (void)_rehasher;
2929 (void)_o;
2930 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2931 auto _color = _o->color;
2932 return MyGame::Example::CreateTestSimpleTableWithEnum(
2933 _fbb,
2934 _color);
2935 }
2936
2937 inline StatT *Stat::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2938 auto _o = std::make_unique<StatT>();
2939 UnPackTo(_o.get(), _resolver);
2940 return _o.release();
2941 }
2942
2943 inline void Stat::UnPackTo(StatT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2944 (void)_o;
2945 (void)_resolver;
2946 { auto _e = id(); if (_e) _o->id = _e->str(); }
2947 { auto _e = val(); _o->val = _e; }
2948 { auto _e = count(); _o->count = _e; }
2949 }
2950
2951 inline ::flatbuffers::Offset<Stat> Stat::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2952 return CreateStat(_fbb, _o, _rehasher);
2953 }
2954
2955 inline ::flatbuffers::Offset<Stat> CreateStat(::flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2956 (void)_rehasher;
2957 (void)_o;
2958 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2959 auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id);
2960 auto _val = _o->val;
2961 auto _count = _o->count;
2962 return MyGame::Example::CreateStat(
2963 _fbb,
2964 _id,
2965 _val,
2966 _count);
2967 }
2968
2969 inline ReferrableT *Referrable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2970 auto _o = std::make_unique<ReferrableT>();
2971 UnPackTo(_o.get(), _resolver);
2972 return _o.release();
2973 }
2974
2975 inline void Referrable::UnPackTo(ReferrableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2976 (void)_o;
2977 (void)_resolver;
2978 { auto _e = id(); _o->id = _e; }
2979 }
2980
2981 inline ::flatbuffers::Offset<Referrable> Referrable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2982 return CreateReferrable(_fbb, _o, _rehasher);
2983 }
2984
2985 inline ::flatbuffers::Offset<Referrable> CreateReferrable(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2986 (void)_rehasher;
2987 (void)_o;
2988 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2989 auto _id = _o->id;
2990 return MyGame::Example::CreateReferrable(
2991 _fbb,
2992 _id);
2993 }
2994
2995 inline MonsterT::MonsterT(const MonsterT &o)
2996 : pos((o.pos) ? new MyGame::Example::Vec3(*o.pos) : nullptr),
2997 mana(o.mana),
2998 hp(o.hp),
2999 name(o.name),
3000 inventory(o.inventory),
3001 color(o.color),
3002 test(o.test),
3003 test4(o.test4),
3004 testarrayofstring(o.testarrayofstring),
3005 enemy((o.enemy) ? new MyGame::Example::MonsterT(*o.enemy) : nullptr),
3006 testnestedflatbuffer(o.testnestedflatbuffer),
3007 testempty((o.testempty) ? new MyGame::Example::StatT(*o.testempty) : nullptr),
3008 testbool(o.testbool),
3009 testhashs32_fnv1(o.testhashs32_fnv1),
3010 testhashu32_fnv1(o.testhashu32_fnv1),
3011 testhashs64_fnv1(o.testhashs64_fnv1),
3012 testhashu64_fnv1(o.testhashu64_fnv1),
3013 testhashs32_fnv1a(o.testhashs32_fnv1a),
3014 testhashu32_fnv1a(o.testhashu32_fnv1a),
3015 testhashs64_fnv1a(o.testhashs64_fnv1a),
3016 testhashu64_fnv1a(o.testhashu64_fnv1a),
3017 testarrayofbools(o.testarrayofbools),
3018 testf(o.testf),
3019 testf2(o.testf2),
3020 testf3(o.testf3),
3021 testarrayofstring2(o.testarrayofstring2),
3022 testarrayofsortedstruct(o.testarrayofsortedstruct),
3023 flex(o.flex),
3024 test5(o.test5),
3025 vector_of_longs(o.vector_of_longs),
3026 vector_of_doubles(o.vector_of_doubles),
3027 parent_namespace_test((o.parent_namespace_test) ? new MyGame::InParentNamespaceT(*o.parent_namespace_test) : nullptr),
3028 single_weak_reference(o.single_weak_reference),
3029 vector_of_weak_references(o.vector_of_weak_references),
3030 co_owning_reference(o.co_owning_reference),
3031 non_owning_reference(o.non_owning_reference),
3032 vector_of_non_owning_references(o.vector_of_non_owning_references),
3033 any_unique(o.any_unique),
3034 any_ambiguous(o.any_ambiguous),
3035 vector_of_enums(o.vector_of_enums),
3036 signed_enum(o.signed_enum),
3037 testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
3038 native_inline(o.native_inline),
3039 long_enum_non_enum_default(o.long_enum_non_enum_default),
3040 long_enum_normal_default(o.long_enum_normal_default),
3041 nan_default(o.nan_default),
3042 inf_default(o.inf_default),
3043 positive_inf_default(o.positive_inf_default),
3044 infinity_default(o.infinity_default),
3045 positive_infinity_default(o.positive_infinity_default),
3046 negative_inf_default(o.negative_inf_default),
3047 negative_infinity_default(o.negative_infinity_default),
3048 double_inf_default(o.double_inf_default) {
3049 testarrayoftables.reserve(o.testarrayoftables.size());
3050 for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
3051 vector_of_referrables.reserve(o.vector_of_referrables.size());
3052 for (const auto &vector_of_referrables_ : o.vector_of_referrables) { vector_of_referrables.emplace_back((vector_of_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_referrables_) : nullptr); }
3053 vector_of_strong_referrables.reserve(o.vector_of_strong_referrables.size());
3054 for (const auto &vector_of_strong_referrables_ : o.vector_of_strong_referrables) { vector_of_strong_referrables.emplace_back((vector_of_strong_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_strong_referrables_) : nullptr); }
3055 vector_of_co_owning_references.reserve(o.vector_of_co_owning_references.size());
3056 for (const auto &vector_of_co_owning_references_ : o.vector_of_co_owning_references) { vector_of_co_owning_references.emplace_back((vector_of_co_owning_references_) ? new ReferrableT(*vector_of_co_owning_references_) : nullptr); }
3057 scalar_key_sorted_tables.reserve(o.scalar_key_sorted_tables.size());
3058 for (const auto &scalar_key_sorted_tables_ : o.scalar_key_sorted_tables) { scalar_key_sorted_tables.emplace_back((scalar_key_sorted_tables_) ? new MyGame::Example::StatT(*scalar_key_sorted_tables_) : nullptr); }
3059 }
3060
3061 inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
3062 std::swap(pos, o.pos);
3063 std::swap(mana, o.mana);
3064 std::swap(hp, o.hp);
3065 std::swap(name, o.name);
3066 std::swap(inventory, o.inventory);
3067 std::swap(color, o.color);
3068 std::swap(test, o.test);
3069 std::swap(test4, o.test4);
3070 std::swap(testarrayofstring, o.testarrayofstring);
3071 std::swap(testarrayoftables, o.testarrayoftables);
3072 std::swap(enemy, o.enemy);
3073 std::swap(testnestedflatbuffer, o.testnestedflatbuffer);
3074 std::swap(testempty, o.testempty);
3075 std::swap(testbool, o.testbool);
3076 std::swap(testhashs32_fnv1, o.testhashs32_fnv1);
3077 std::swap(testhashu32_fnv1, o.testhashu32_fnv1);
3078 std::swap(testhashs64_fnv1, o.testhashs64_fnv1);
3079 std::swap(testhashu64_fnv1, o.testhashu64_fnv1);
3080 std::swap(testhashs32_fnv1a, o.testhashs32_fnv1a);
3081 std::swap(testhashu32_fnv1a, o.testhashu32_fnv1a);
3082 std::swap(testhashs64_fnv1a, o.testhashs64_fnv1a);
3083 std::swap(testhashu64_fnv1a, o.testhashu64_fnv1a);
3084 std::swap(testarrayofbools, o.testarrayofbools);
3085 std::swap(testf, o.testf);
3086 std::swap(testf2, o.testf2);
3087 std::swap(testf3, o.testf3);
3088 std::swap(testarrayofstring2, o.testarrayofstring2);
3089 std::swap(testarrayofsortedstruct, o.testarrayofsortedstruct);
3090 std::swap(flex, o.flex);
3091 std::swap(test5, o.test5);
3092 std::swap(vector_of_longs, o.vector_of_longs);
3093 std::swap(vector_of_doubles, o.vector_of_doubles);
3094 std::swap(parent_namespace_test, o.parent_namespace_test);
3095 std::swap(vector_of_referrables, o.vector_of_referrables);
3096 std::swap(single_weak_reference, o.single_weak_reference);
3097 std::swap(vector_of_weak_references, o.vector_of_weak_references);
3098 std::swap(vector_of_strong_referrables, o.vector_of_strong_referrables);
3099 std::swap(co_owning_reference, o.co_owning_reference);
3100 std::swap(vector_of_co_owning_references, o.vector_of_co_owning_references);
3101 std::swap(non_owning_reference, o.non_owning_reference);
3102 std::swap(vector_of_non_owning_references, o.vector_of_non_owning_references);
3103 std::swap(any_unique, o.any_unique);
3104 std::swap(any_ambiguous, o.any_ambiguous);
3105 std::swap(vector_of_enums, o.vector_of_enums);
3106 std::swap(signed_enum, o.signed_enum);
3107 std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer);
3108 std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables);
3109 std::swap(native_inline, o.native_inline);
3110 std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
3111 std::swap(long_enum_normal_default, o.long_enum_normal_default);
3112 std::swap(nan_default, o.nan_default);
3113 std::swap(inf_default, o.inf_default);
3114 std::swap(positive_inf_default, o.positive_inf_default);
3115 std::swap(infinity_default, o.infinity_default);
3116 std::swap(positive_infinity_default, o.positive_infinity_default);
3117 std::swap(negative_inf_default, o.negative_inf_default);
3118 std::swap(negative_infinity_default, o.negative_infinity_default);
3119 std::swap(double_inf_default, o.double_inf_default);
3120 return *this;
3121 }
3122
3123 inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
3124 auto _o = std::make_unique<MonsterT>();
3125 UnPackTo(_o.get(), _resolver);
3126 return _o.release();
3127 }
3128
3129 inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
3130 (void)_o;
3131 (void)_resolver;
3132 { auto _e = pos(); if (_e) _o->pos = std::unique_ptr<MyGame::Example::Vec3>(new MyGame::Example::Vec3(*_e)); }
3133 { auto _e = mana(); _o->mana = _e; }
3134 { auto _e = hp(); _o->hp = _e; }
3135 { auto _e = name(); if (_e) _o->name = _e->str(); }
3136 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } }
3137 { auto _e = color(); _o->color = _e; }
3138 { auto _e = test_type(); _o->test.type = _e; }
3139 { auto _e = test(); if (_e) _o->test.value = MyGame::Example::AnyUnion::UnPack(_e, test_type(), _resolver); }
3140 { auto _e = test4(); if (_e) { _o->test4.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4[_i] = *_e->Get(_i); } } else { _o->test4.resize(0); } }
3141 { auto _e = testarrayofstring(); if (_e) { _o->testarrayofstring.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring[_i] = _e->Get(_i)->str(); } } else { _o->testarrayofstring.resize(0); } }
3142 { auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->testarrayoftables[_i]) { _e->Get(_i)->UnPackTo(_o->testarrayoftables[_i].get(), _resolver); } else { _o->testarrayoftables[_i] = std::unique_ptr<MyGame::Example::MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->testarrayoftables.resize(0); } }
3143 { auto _e = enemy(); if (_e) { if(_o->enemy) { _e->UnPackTo(_o->enemy.get(), _resolver); } else { _o->enemy = std::unique_ptr<MyGame::Example::MonsterT>(_e->UnPack(_resolver)); } } else if (_o->enemy) { _o->enemy.reset(); } }
3144 { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testnestedflatbuffer.begin()); } }
3145 { auto _e = testempty(); if (_e) { if(_o->testempty) { _e->UnPackTo(_o->testempty.get(), _resolver); } else { _o->testempty = std::unique_ptr<MyGame::Example::StatT>(_e->UnPack(_resolver)); } } else if (_o->testempty) { _o->testempty.reset(); } }
3146 { auto _e = testbool(); _o->testbool = _e; }
3147 { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }
3148 { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; }
3149 { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; }
3150 { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; }
3151 { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; }
3152 { auto _e = testhashu32_fnv1a(); /*scalar resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->testhashu32_fnv1a), static_cast<::flatbuffers::hash_value_t>(_e)); else _o->testhashu32_fnv1a = nullptr; }
3153 { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; }
3154 { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; }
3155 { auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } else { _o->testarrayofbools.resize(0); } }
3156 { auto _e = testf(); _o->testf = _e; }
3157 { auto _e = testf2(); _o->testf2 = _e; }
3158 { auto _e = testf3(); _o->testf3 = _e; }
3159 { auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } else { _o->testarrayofstring2.resize(0); } }
3160 { auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } else { _o->testarrayofsortedstruct.resize(0); } }
3161 { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->flex.begin()); } }
3162 { auto _e = test5(); if (_e) { _o->test5.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test5[_i] = *_e->Get(_i); } } else { _o->test5.resize(0); } }
3163 { auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } else { _o->vector_of_longs.resize(0); } }
3164 { auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } else { _o->vector_of_doubles.resize(0); } }
3165 { auto _e = parent_namespace_test(); if (_e) { if(_o->parent_namespace_test) { _e->UnPackTo(_o->parent_namespace_test.get(), _resolver); } else { _o->parent_namespace_test = std::unique_ptr<MyGame::InParentNamespaceT>(_e->UnPack(_resolver)); } } else if (_o->parent_namespace_test) { _o->parent_namespace_test.reset(); } }
3166 { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_referrables[_i].get(), _resolver); } else { _o->vector_of_referrables[_i] = std::unique_ptr<MyGame::Example::ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->vector_of_referrables.resize(0); } }
3167 { auto _e = single_weak_reference(); /*scalar resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->single_weak_reference), static_cast<::flatbuffers::hash_value_t>(_e)); else _o->single_weak_reference = nullptr; }
3168 { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { /*vector resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_weak_references[_i]), static_cast<::flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } else { _o->vector_of_weak_references.resize(0); } }
3169 { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_strong_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_strong_referrables[_i].get(), _resolver); } else { _o->vector_of_strong_referrables[_i] = std::unique_ptr<MyGame::Example::ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->vector_of_strong_referrables.resize(0); } }
3170 { auto _e = co_owning_reference(); /*scalar resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->co_owning_reference), static_cast<::flatbuffers::hash_value_t>(_e)); else _o->co_owning_reference = nullptr; }
3171 { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { /*vector resolver, default_ptr_type*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_co_owning_references[_i]), static_cast<::flatbuffers::hash_value_t>(_e->Get(_i)));/* else do nothing */} } else { _o->vector_of_co_owning_references.resize(0); } }
3172 { auto _e = non_owning_reference(); /*scalar resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->non_owning_reference), static_cast<::flatbuffers::hash_value_t>(_e)); else _o->non_owning_reference = nullptr; }
3173 { auto _e = vector_of_non_owning_references(); if (_e) { _o->vector_of_non_owning_references.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { /*vector resolver, naked*/ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_references[_i]), static_cast<::flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_non_owning_references[_i] = nullptr; } } else { _o->vector_of_non_owning_references.resize(0); } }
3174 { auto _e = any_unique_type(); _o->any_unique.type = _e; }
3175 { auto _e = any_unique(); if (_e) _o->any_unique.value = MyGame::Example::AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); }
3176 { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; }
3177 { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
3178 { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<MyGame::Example::Color>(_e->Get(_i)); } } else { _o->vector_of_enums.resize(0); } }
3179 { auto _e = signed_enum(); _o->signed_enum = _e; }
3180 { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
3181 { auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = std::unique_ptr<MyGame::Example::StatT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->scalar_key_sorted_tables.resize(0); } }
3182 { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
3183 { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
3184 { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
3185 { auto _e = nan_default(); _o->nan_default = _e; }
3186 { auto _e = inf_default(); _o->inf_default = _e; }
3187 { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
3188 { auto _e = infinity_default(); _o->infinity_default = _e; }
3189 { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
3190 { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
3191 { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
3192 { auto _e = double_inf_default(); _o->double_inf_default = _e; }
3193 }
3194
3195 inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3196 return CreateMonster(_fbb, _o, _rehasher);
3197 }
3198
3199 inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3200 (void)_rehasher;
3201 (void)_o;
3202 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3203 auto _pos = _o->pos ? _o->pos.get() : nullptr;
3204 auto _mana = _o->mana;
3205 auto _hp = _o->hp;
3206 auto _name = _fbb.CreateString(_o->name);
3207 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
3208 auto _color = _o->color;
3209 auto _test_type = _o->test.type;
3210 auto _test = _o->test.Pack(_fbb);
3211 auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
3212 auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
3213 auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
3214 auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
3215 auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
3216 auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
3217 auto _testbool = _o->testbool;
3218 auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
3219 auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
3220 auto _testhashs64_fnv1 = _o->testhashs64_fnv1;
3221 auto _testhashu64_fnv1 = _o->testhashu64_fnv1;
3222 auto _testhashs32_fnv1a = _o->testhashs32_fnv1a;
3223 auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0;
3224 auto _testhashs64_fnv1a = _o->testhashs64_fnv1a;
3225 auto _testhashu64_fnv1a = _o->testhashu64_fnv1a;
3226 auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0;
3227 auto _testf = _o->testf;
3228 auto _testf2 = _o->testf2;
3229 auto _testf3 = _o->testf3;
3230 auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0;
3231 auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0;
3232 auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0;
3233 auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0;
3234 auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
3235 auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
3236 auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
3237 auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
3238 auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
3239 auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0;
3240 auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
3241 auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0;
3242 auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0;
3243 auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0;
3244 auto _vector_of_non_owning_references = _o->vector_of_non_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_non_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_non_owning_references[i])) : 0; }, &_va ) : 0;
3245 auto _any_unique_type = _o->any_unique.type;
3246 auto _any_unique = _o->any_unique.Pack(_fbb);
3247 auto _any_ambiguous_type = _o->any_ambiguous.type;
3248 auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
3249 auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
3250 auto _signed_enum = _o->signed_enum;
3251 auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
3252 auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
3253 auto _native_inline = &_o->native_inline;
3254 auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
3255 auto _long_enum_normal_default = _o->long_enum_normal_default;
3256 auto _nan_default = _o->nan_default;
3257 auto _inf_default = _o->inf_default;
3258 auto _positive_inf_default = _o->positive_inf_default;
3259 auto _infinity_default = _o->infinity_default;
3260 auto _positive_infinity_default = _o->positive_infinity_default;
3261 auto _negative_inf_default = _o->negative_inf_default;
3262 auto _negative_infinity_default = _o->negative_infinity_default;
3263 auto _double_inf_default = _o->double_inf_default;
3264 return MyGame::Example::CreateMonster(
3265 _fbb,
3266 _pos,
3267 _mana,
3268 _hp,
3269 _name,
3270 _inventory,
3271 _color,
3272 _test_type,
3273 _test,
3274 _test4,
3275 _testarrayofstring,
3276 _testarrayoftables,
3277 _enemy,
3278 _testnestedflatbuffer,
3279 _testempty,
3280 _testbool,
3281 _testhashs32_fnv1,
3282 _testhashu32_fnv1,
3283 _testhashs64_fnv1,
3284 _testhashu64_fnv1,
3285 _testhashs32_fnv1a,
3286 _testhashu32_fnv1a,
3287 _testhashs64_fnv1a,
3288 _testhashu64_fnv1a,
3289 _testarrayofbools,
3290 _testf,
3291 _testf2,
3292 _testf3,
3293 _testarrayofstring2,
3294 _testarrayofsortedstruct,
3295 _flex,
3296 _test5,
3297 _vector_of_longs,
3298 _vector_of_doubles,
3299 _parent_namespace_test,
3300 _vector_of_referrables,
3301 _single_weak_reference,
3302 _vector_of_weak_references,
3303 _vector_of_strong_referrables,
3304 _co_owning_reference,
3305 _vector_of_co_owning_references,
3306 _non_owning_reference,
3307 _vector_of_non_owning_references,
3308 _any_unique_type,
3309 _any_unique,
3310 _any_ambiguous_type,
3311 _any_ambiguous,
3312 _vector_of_enums,
3313 _signed_enum,
3314 _testrequirednestedflatbuffer,
3315 _scalar_key_sorted_tables,
3316 _native_inline,
3317 _long_enum_non_enum_default,
3318 _long_enum_normal_default,
3319 _nan_default,
3320 _inf_default,
3321 _positive_inf_default,
3322 _infinity_default,
3323 _positive_infinity_default,
3324 _negative_inf_default,
3325 _negative_infinity_default,
3326 _double_inf_default);
3327 }
3328
3329 inline TypeAliasesT *TypeAliases::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
3330 auto _o = std::make_unique<TypeAliasesT>();
3331 UnPackTo(_o.get(), _resolver);
3332 return _o.release();
3333 }
3334
3335 inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
3336 (void)_o;
3337 (void)_resolver;
3338 { auto _e = i8(); _o->i8 = _e; }
3339 { auto _e = u8(); _o->u8 = _e; }
3340 { auto _e = i16(); _o->i16 = _e; }
3341 { auto _e = u16(); _o->u16 = _e; }
3342 { auto _e = i32(); _o->i32 = _e; }
3343 { auto _e = u32(); _o->u32 = _e; }
3344 { auto _e = i64(); _o->i64 = _e; }
3345 { auto _e = u64(); _o->u64 = _e; }
3346 { auto _e = f32(); _o->f32 = _e; }
3347 { auto _e = f64(); _o->f64 = _e; }
3348 { auto _e = v8(); if (_e) { _o->v8.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->v8.begin()); } }
3349 { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } else { _o->vf64.resize(0); } }
3350 }
3351
3352 inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3353 return CreateTypeAliases(_fbb, _o, _rehasher);
3354 }
3355
3356 inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3357 (void)_rehasher;
3358 (void)_o;
3359 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3360 auto _i8 = _o->i8;
3361 auto _u8 = _o->u8;
3362 auto _i16 = _o->i16;
3363 auto _u16 = _o->u16;
3364 auto _i32 = _o->i32;
3365 auto _u32 = _o->u32;
3366 auto _i64 = _o->i64;
3367 auto _u64 = _o->u64;
3368 auto _f32 = _o->f32;
3369 auto _f64 = _o->f64;
3370 auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0;
3371 auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0;
3372 return MyGame::Example::CreateTypeAliases(
3373 _fbb,
3374 _i8,
3375 _u8,
3376 _i16,
3377 _u16,
3378 _i32,
3379 _u32,
3380 _i64,
3381 _u64,
3382 _f32,
3383 _f64,
3384 _v8,
3385 _vf64);
3386 }
3387
3388 inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
3389 switch (type) {
3390 case Any::NONE: {
3391 return true;
3392 }
3393 case Any::Monster: {
3394 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3395 return verifier.VerifyTable(ptr);
3396 }
3397 case Any::TestSimpleTableWithEnum: {
3398 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3399 return verifier.VerifyTable(ptr);
3400 }
3401 case Any::MyGame_Example2_Monster: {
3402 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3403 return verifier.VerifyTable(ptr);
3404 }
3405 default: return true;
3406 }
3407 }
3408
3409 inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
3410 if (!values || !types) return !values && !types;
3411 if (values->size() != types->size()) return false;
3412 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3413 if (!VerifyAny(
3414 verifier, values->Get(i), types->GetEnum<Any>(i))) {
3415 return false;
3416 }
3417 }
3418 return true;
3419 }
3420
3421 inline void *AnyUnion::UnPack(const void *obj, Any type, const ::flatbuffers::resolver_function_t *resolver) {
3422 (void)resolver;
3423 switch (type) {
3424 case Any::Monster: {
3425 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3426 return ptr->UnPack(resolver);
3427 }
3428 case Any::TestSimpleTableWithEnum: {
3429 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3430 return ptr->UnPack(resolver);
3431 }
3432 case Any::MyGame_Example2_Monster: {
3433 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3434 return ptr->UnPack(resolver);
3435 }
3436 default: return nullptr;
3437 }
3438 }
3439
3440 inline ::flatbuffers::Offset<void> AnyUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3441 (void)_rehasher;
3442 switch (type) {
3443 case Any::Monster: {
3444 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3445 return CreateMonster(_fbb, ptr, _rehasher).Union();
3446 }
3447 case Any::TestSimpleTableWithEnum: {
3448 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value);
3449 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
3450 }
3451 case Any::MyGame_Example2_Monster: {
3452 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
3453 return CreateMonster(_fbb, ptr, _rehasher).Union();
3454 }
3455 default: return 0;
3456 }
3457 }
3458
3459 inline AnyUnion::AnyUnion(const AnyUnion &u) : type(u.type), value(nullptr) {
3460 switch (type) {
3461 case Any::Monster: {
3462 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3463 break;
3464 }
3465 case Any::TestSimpleTableWithEnum: {
3466 value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(u.value));
3467 break;
3468 }
3469 case Any::MyGame_Example2_Monster: {
3470 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
3471 break;
3472 }
3473 default:
3474 break;
3475 }
3476 }
3477
3478 inline void AnyUnion::Reset() {
3479 switch (type) {
3480 case Any::Monster: {
3481 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3482 delete ptr;
3483 break;
3484 }
3485 case Any::TestSimpleTableWithEnum: {
3486 auto ptr = reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value);
3487 delete ptr;
3488 break;
3489 }
3490 case Any::MyGame_Example2_Monster: {
3491 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
3492 delete ptr;
3493 break;
3494 }
3495 default: break;
3496 }
3497 value = nullptr;
3498 type = Any::NONE;
3499 }
3500
3501 inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
3502 switch (type) {
3503 case AnyUniqueAliases::NONE: {
3504 return true;
3505 }
3506 case AnyUniqueAliases::M: {
3507 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3508 return verifier.VerifyTable(ptr);
3509 }
3510 case AnyUniqueAliases::TS: {
3511 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3512 return verifier.VerifyTable(ptr);
3513 }
3514 case AnyUniqueAliases::M2: {
3515 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3516 return verifier.VerifyTable(ptr);
3517 }
3518 default: return true;
3519 }
3520 }
3521
3522 inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
3523 if (!values || !types) return !values && !types;
3524 if (values->size() != types->size()) return false;
3525 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3526 if (!VerifyAnyUniqueAliases(
3527 verifier, values->Get(i), types->GetEnum<AnyUniqueAliases>(i))) {
3528 return false;
3529 }
3530 }
3531 return true;
3532 }
3533
3534 inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const ::flatbuffers::resolver_function_t *resolver) {
3535 (void)resolver;
3536 switch (type) {
3537 case AnyUniqueAliases::M: {
3538 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3539 return ptr->UnPack(resolver);
3540 }
3541 case AnyUniqueAliases::TS: {
3542 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3543 return ptr->UnPack(resolver);
3544 }
3545 case AnyUniqueAliases::M2: {
3546 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3547 return ptr->UnPack(resolver);
3548 }
3549 default: return nullptr;
3550 }
3551 }
3552
3553 inline ::flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3554 (void)_rehasher;
3555 switch (type) {
3556 case AnyUniqueAliases::M: {
3557 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3558 return CreateMonster(_fbb, ptr, _rehasher).Union();
3559 }
3560 case AnyUniqueAliases::TS: {
3561 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value);
3562 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
3563 }
3564 case AnyUniqueAliases::M2: {
3565 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
3566 return CreateMonster(_fbb, ptr, _rehasher).Union();
3567 }
3568 default: return 0;
3569 }
3570 }
3571
3572 inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : type(u.type), value(nullptr) {
3573 switch (type) {
3574 case AnyUniqueAliases::M: {
3575 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3576 break;
3577 }
3578 case AnyUniqueAliases::TS: {
3579 value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(u.value));
3580 break;
3581 }
3582 case AnyUniqueAliases::M2: {
3583 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
3584 break;
3585 }
3586 default:
3587 break;
3588 }
3589 }
3590
3591 inline void AnyUniqueAliasesUnion::Reset() {
3592 switch (type) {
3593 case AnyUniqueAliases::M: {
3594 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3595 delete ptr;
3596 break;
3597 }
3598 case AnyUniqueAliases::TS: {
3599 auto ptr = reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value);
3600 delete ptr;
3601 break;
3602 }
3603 case AnyUniqueAliases::M2: {
3604 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
3605 delete ptr;
3606 break;
3607 }
3608 default: break;
3609 }
3610 value = nullptr;
3611 type = AnyUniqueAliases::NONE;
3612 }
3613
3614 inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
3615 switch (type) {
3616 case AnyAmbiguousAliases::NONE: {
3617 return true;
3618 }
3619 case AnyAmbiguousAliases::M1: {
3620 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3621 return verifier.VerifyTable(ptr);
3622 }
3623 case AnyAmbiguousAliases::M2: {
3624 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3625 return verifier.VerifyTable(ptr);
3626 }
3627 case AnyAmbiguousAliases::M3: {
3628 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3629 return verifier.VerifyTable(ptr);
3630 }
3631 default: return true;
3632 }
3633 }
3634
3635 inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
3636 if (!values || !types) return !values && !types;
3637 if (values->size() != types->size()) return false;
3638 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3639 if (!VerifyAnyAmbiguousAliases(
3640 verifier, values->Get(i), types->GetEnum<AnyAmbiguousAliases>(i))) {
3641 return false;
3642 }
3643 }
3644 return true;
3645 }
3646
3647 inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const ::flatbuffers::resolver_function_t *resolver) {
3648 (void)resolver;
3649 switch (type) {
3650 case AnyAmbiguousAliases::M1: {
3651 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3652 return ptr->UnPack(resolver);
3653 }
3654 case AnyAmbiguousAliases::M2: {
3655 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3656 return ptr->UnPack(resolver);
3657 }
3658 case AnyAmbiguousAliases::M3: {
3659 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3660 return ptr->UnPack(resolver);
3661 }
3662 default: return nullptr;
3663 }
3664 }
3665
3666 inline ::flatbuffers::Offset<void> AnyAmbiguousAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3667 (void)_rehasher;
3668 switch (type) {
3669 case AnyAmbiguousAliases::M1: {
3670 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3671 return CreateMonster(_fbb, ptr, _rehasher).Union();
3672 }
3673 case AnyAmbiguousAliases::M2: {
3674 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3675 return CreateMonster(_fbb, ptr, _rehasher).Union();
3676 }
3677 case AnyAmbiguousAliases::M3: {
3678 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3679 return CreateMonster(_fbb, ptr, _rehasher).Union();
3680 }
3681 default: return 0;
3682 }
3683 }
3684
3685 inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : type(u.type), value(nullptr) {
3686 switch (type) {
3687 case AnyAmbiguousAliases::M1: {
3688 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3689 break;
3690 }
3691 case AnyAmbiguousAliases::M2: {
3692 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3693 break;
3694 }
3695 case AnyAmbiguousAliases::M3: {
3696 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3697 break;
3698 }
3699 default:
3700 break;
3701 }
3702 }
3703
3704 inline void AnyAmbiguousAliasesUnion::Reset() {
3705 switch (type) {
3706 case AnyAmbiguousAliases::M1: {
3707 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3708 delete ptr;
3709 break;
3710 }
3711 case AnyAmbiguousAliases::M2: {
3712 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3713 delete ptr;
3714 break;
3715 }
3716 case AnyAmbiguousAliases::M3: {
3717 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3718 delete ptr;
3719 break;
3720 }
3721 default: break;
3722 }
3723 value = nullptr;
3724 type = AnyAmbiguousAliases::NONE;
3725 }
3726
3727 inline const ::flatbuffers::TypeTable *ColorTypeTable() {
3728 static const ::flatbuffers::TypeCode type_codes[] = {
3729 { ::flatbuffers::ET_UCHAR, 0, 0 },
3730 { ::flatbuffers::ET_UCHAR, 0, 0 },
3731 { ::flatbuffers::ET_UCHAR, 0, 0 }
3732 };
3733 static const ::flatbuffers::TypeFunction type_refs[] = {
3734 MyGame::Example::ColorTypeTable
3735 };
3736 static const int64_t values[] = { 1, 2, 8 };
3737 static const char * const names[] = {
3738 "Red",
3739 "Green",
3740 "Blue"
3741 };
3742 static const ::flatbuffers::TypeTable tt = {
3743 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names
3744 };
3745 return &tt;
3746 }
3747
3748 inline const ::flatbuffers::TypeTable *RaceTypeTable() {
3749 static const ::flatbuffers::TypeCode type_codes[] = {
3750 { ::flatbuffers::ET_CHAR, 0, 0 },
3751 { ::flatbuffers::ET_CHAR, 0, 0 },
3752 { ::flatbuffers::ET_CHAR, 0, 0 },
3753 { ::flatbuffers::ET_CHAR, 0, 0 }
3754 };
3755 static const ::flatbuffers::TypeFunction type_refs[] = {
3756 MyGame::Example::RaceTypeTable
3757 };
3758 static const int64_t values[] = { -1, 0, 1, 2 };
3759 static const char * const names[] = {
3760 "None",
3761 "Human",
3762 "Dwarf",
3763 "Elf"
3764 };
3765 static const ::flatbuffers::TypeTable tt = {
3766 ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names
3767 };
3768 return &tt;
3769 }
3770
3771 inline const ::flatbuffers::TypeTable *LongEnumTypeTable() {
3772 static const ::flatbuffers::TypeCode type_codes[] = {
3773 { ::flatbuffers::ET_ULONG, 0, 0 },
3774 { ::flatbuffers::ET_ULONG, 0, 0 },
3775 { ::flatbuffers::ET_ULONG, 0, 0 }
3776 };
3777 static const ::flatbuffers::TypeFunction type_refs[] = {
3778 MyGame::Example::LongEnumTypeTable
3779 };
3780 static const int64_t values[] = { 2ULL, 4ULL, 1099511627776ULL };
3781 static const char * const names[] = {
3782 "LongOne",
3783 "LongTwo",
3784 "LongBig"
3785 };
3786 static const ::flatbuffers::TypeTable tt = {
3787 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names
3788 };
3789 return &tt;
3790 }
3791
3792 inline const ::flatbuffers::TypeTable *AnyTypeTable() {
3793 static const ::flatbuffers::TypeCode type_codes[] = {
3794 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3795 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3796 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3797 { ::flatbuffers::ET_SEQUENCE, 0, 2 }
3798 };
3799 static const ::flatbuffers::TypeFunction type_refs[] = {
3800 MyGame::Example::MonsterTypeTable,
3801 MyGame::Example::TestSimpleTableWithEnumTypeTable,
3802 MyGame::Example2::MonsterTypeTable
3803 };
3804 static const char * const names[] = {
3805 "NONE",
3806 "Monster",
3807 "TestSimpleTableWithEnum",
3808 "MyGame_Example2_Monster"
3809 };
3810 static const ::flatbuffers::TypeTable tt = {
3811 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3812 };
3813 return &tt;
3814 }
3815
3816 inline const ::flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() {
3817 static const ::flatbuffers::TypeCode type_codes[] = {
3818 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3819 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3820 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3821 { ::flatbuffers::ET_SEQUENCE, 0, 2 }
3822 };
3823 static const ::flatbuffers::TypeFunction type_refs[] = {
3824 MyGame::Example::MonsterTypeTable,
3825 MyGame::Example::TestSimpleTableWithEnumTypeTable,
3826 MyGame::Example2::MonsterTypeTable
3827 };
3828 static const char * const names[] = {
3829 "NONE",
3830 "M",
3831 "TS",
3832 "M2"
3833 };
3834 static const ::flatbuffers::TypeTable tt = {
3835 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3836 };
3837 return &tt;
3838 }
3839
3840 inline const ::flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() {
3841 static const ::flatbuffers::TypeCode type_codes[] = {
3842 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3843 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3844 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3845 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3846 };
3847 static const ::flatbuffers::TypeFunction type_refs[] = {
3848 MyGame::Example::MonsterTypeTable
3849 };
3850 static const char * const names[] = {
3851 "NONE",
3852 "M1",
3853 "M2",
3854 "M3"
3855 };
3856 static const ::flatbuffers::TypeTable tt = {
3857 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3858 };
3859 return &tt;
3860 }
3861
3862 } // namespace Example
3863
3864 inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable() {
3865 static const ::flatbuffers::TypeTable tt = {
3866 ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
3867 };
3868 return &tt;
3869 }
3870
3871 namespace Example2 {
3872
3873 inline const ::flatbuffers::TypeTable *MonsterTypeTable() {
3874 static const ::flatbuffers::TypeTable tt = {
3875 ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
3876 };
3877 return &tt;
3878 }
3879
3880 } // namespace Example2
3881
3882 namespace Example {
3883
3884 inline const ::flatbuffers::TypeTable *TestTypeTable() {
3885 static const ::flatbuffers::TypeCode type_codes[] = {
3886 { ::flatbuffers::ET_SHORT, 0, -1 },
3887 { ::flatbuffers::ET_CHAR, 0, -1 }
3888 };
3889 static const int64_t values[] = { 0, 2, 4 };
3890 static const char * const names[] = {
3891 "a",
3892 "b"
3893 };
3894 static const ::flatbuffers::TypeTable tt = {
3895 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
3896 };
3897 return &tt;
3898 }
3899
3900 inline const ::flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() {
3901 static const ::flatbuffers::TypeCode type_codes[] = {
3902 { ::flatbuffers::ET_UCHAR, 0, 0 }
3903 };
3904 static const ::flatbuffers::TypeFunction type_refs[] = {
3905 MyGame::Example::ColorTypeTable
3906 };
3907 static const char * const names[] = {
3908 "color"
3909 };
3910 static const ::flatbuffers::TypeTable tt = {
3911 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
3912 };
3913 return &tt;
3914 }
3915
3916 inline const ::flatbuffers::TypeTable *Vec3TypeTable() {
3917 static const ::flatbuffers::TypeCode type_codes[] = {
3918 { ::flatbuffers::ET_FLOAT, 0, -1 },
3919 { ::flatbuffers::ET_FLOAT, 0, -1 },
3920 { ::flatbuffers::ET_FLOAT, 0, -1 },
3921 { ::flatbuffers::ET_DOUBLE, 0, -1 },
3922 { ::flatbuffers::ET_UCHAR, 0, 0 },
3923 { ::flatbuffers::ET_SEQUENCE, 0, 1 }
3924 };
3925 static const ::flatbuffers::TypeFunction type_refs[] = {
3926 MyGame::Example::ColorTypeTable,
3927 MyGame::Example::TestTypeTable
3928 };
3929 static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 };
3930 static const char * const names[] = {
3931 "x",
3932 "y",
3933 "z",
3934 "test1",
3935 "test2",
3936 "test3"
3937 };
3938 static const ::flatbuffers::TypeTable tt = {
3939 ::flatbuffers::ST_STRUCT, 6, type_codes, type_refs, nullptr, values, names
3940 };
3941 return &tt;
3942 }
3943
3944 inline const ::flatbuffers::TypeTable *AbilityTypeTable() {
3945 static const ::flatbuffers::TypeCode type_codes[] = {
3946 { ::flatbuffers::ET_UINT, 0, -1 },
3947 { ::flatbuffers::ET_UINT, 0, -1 }
3948 };
3949 static const int64_t values[] = { 0, 4, 8 };
3950 static const char * const names[] = {
3951 "id",
3952 "distance"
3953 };
3954 static const ::flatbuffers::TypeTable tt = {
3955 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
3956 };
3957 return &tt;
3958 }
3959
3960 inline const ::flatbuffers::TypeTable *StructOfStructsTypeTable() {
3961 static const ::flatbuffers::TypeCode type_codes[] = {
3962 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3963 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3964 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3965 };
3966 static const ::flatbuffers::TypeFunction type_refs[] = {
3967 MyGame::Example::AbilityTypeTable,
3968 MyGame::Example::TestTypeTable
3969 };
3970 static const int64_t values[] = { 0, 8, 12, 20 };
3971 static const char * const names[] = {
3972 "a",
3973 "b",
3974 "c"
3975 };
3976 static const ::flatbuffers::TypeTable tt = {
3977 ::flatbuffers::ST_STRUCT, 3, type_codes, type_refs, nullptr, values, names
3978 };
3979 return &tt;
3980 }
3981
3982 inline const ::flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() {
3983 static const ::flatbuffers::TypeCode type_codes[] = {
3984 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3985 };
3986 static const ::flatbuffers::TypeFunction type_refs[] = {
3987 MyGame::Example::StructOfStructsTypeTable
3988 };
3989 static const int64_t values[] = { 0, 20 };
3990 static const char * const names[] = {
3991 "a"
3992 };
3993 static const ::flatbuffers::TypeTable tt = {
3994 ::flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, names
3995 };
3996 return &tt;
3997 }
3998
3999 inline const ::flatbuffers::TypeTable *StatTypeTable() {
4000 static const ::flatbuffers::TypeCode type_codes[] = {
4001 { ::flatbuffers::ET_STRING, 0, -1 },
4002 { ::flatbuffers::ET_LONG, 0, -1 },
4003 { ::flatbuffers::ET_USHORT, 0, -1 }
4004 };
4005 static const char * const names[] = {
4006 "id",
4007 "val",
4008 "count"
4009 };
4010 static const ::flatbuffers::TypeTable tt = {
4011 ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
4012 };
4013 return &tt;
4014 }
4015
4016 inline const ::flatbuffers::TypeTable *ReferrableTypeTable() {
4017 static const ::flatbuffers::TypeCode type_codes[] = {
4018 { ::flatbuffers::ET_ULONG, 0, -1 }
4019 };
4020 static const char * const names[] = {
4021 "id"
4022 };
4023 static const ::flatbuffers::TypeTable tt = {
4024 ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
4025 };
4026 return &tt;
4027 }
4028
4029 inline const ::flatbuffers::TypeTable *MonsterTypeTable() {
4030 static const ::flatbuffers::TypeCode type_codes[] = {
4031 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
4032 { ::flatbuffers::ET_SHORT, 0, -1 },
4033 { ::flatbuffers::ET_SHORT, 0, -1 },
4034 { ::flatbuffers::ET_STRING, 0, -1 },
4035 { ::flatbuffers::ET_BOOL, 0, -1 },
4036 { ::flatbuffers::ET_UCHAR, 1, -1 },
4037 { ::flatbuffers::ET_UCHAR, 0, 1 },
4038 { ::flatbuffers::ET_UTYPE, 0, 2 },
4039 { ::flatbuffers::ET_SEQUENCE, 0, 2 },
4040 { ::flatbuffers::ET_SEQUENCE, 1, 3 },
4041 { ::flatbuffers::ET_STRING, 1, -1 },
4042 { ::flatbuffers::ET_SEQUENCE, 1, 4 },
4043 { ::flatbuffers::ET_SEQUENCE, 0, 4 },
4044 { ::flatbuffers::ET_UCHAR, 1, -1 },
4045 { ::flatbuffers::ET_SEQUENCE, 0, 5 },
4046 { ::flatbuffers::ET_BOOL, 0, -1 },
4047 { ::flatbuffers::ET_INT, 0, -1 },
4048 { ::flatbuffers::ET_UINT, 0, -1 },
4049 { ::flatbuffers::ET_LONG, 0, -1 },
4050 { ::flatbuffers::ET_ULONG, 0, -1 },
4051 { ::flatbuffers::ET_INT, 0, -1 },
4052 { ::flatbuffers::ET_UINT, 0, -1 },
4053 { ::flatbuffers::ET_LONG, 0, -1 },
4054 { ::flatbuffers::ET_ULONG, 0, -1 },
4055 { ::flatbuffers::ET_BOOL, 1, -1 },
4056 { ::flatbuffers::ET_FLOAT, 0, -1 },
4057 { ::flatbuffers::ET_FLOAT, 0, -1 },
4058 { ::flatbuffers::ET_FLOAT, 0, -1 },
4059 { ::flatbuffers::ET_STRING, 1, -1 },
4060 { ::flatbuffers::ET_SEQUENCE, 1, 6 },
4061 { ::flatbuffers::ET_UCHAR, 1, -1 },
4062 { ::flatbuffers::ET_SEQUENCE, 1, 3 },
4063 { ::flatbuffers::ET_LONG, 1, -1 },
4064 { ::flatbuffers::ET_DOUBLE, 1, -1 },
4065 { ::flatbuffers::ET_SEQUENCE, 0, 7 },
4066 { ::flatbuffers::ET_SEQUENCE, 1, 8 },
4067 { ::flatbuffers::ET_ULONG, 0, -1 },
4068 { ::flatbuffers::ET_ULONG, 1, -1 },
4069 { ::flatbuffers::ET_SEQUENCE, 1, 8 },
4070 { ::flatbuffers::ET_ULONG, 0, -1 },
4071 { ::flatbuffers::ET_ULONG, 1, -1 },
4072 { ::flatbuffers::ET_ULONG, 0, -1 },
4073 { ::flatbuffers::ET_ULONG, 1, -1 },
4074 { ::flatbuffers::ET_UTYPE, 0, 9 },
4075 { ::flatbuffers::ET_SEQUENCE, 0, 9 },
4076 { ::flatbuffers::ET_UTYPE, 0, 10 },
4077 { ::flatbuffers::ET_SEQUENCE, 0, 10 },
4078 { ::flatbuffers::ET_UCHAR, 1, 1 },
4079 { ::flatbuffers::ET_CHAR, 0, 11 },
4080 { ::flatbuffers::ET_UCHAR, 1, -1 },
4081 { ::flatbuffers::ET_SEQUENCE, 1, 5 },
4082 { ::flatbuffers::ET_SEQUENCE, 0, 3 },
4083 { ::flatbuffers::ET_ULONG, 0, 12 },
4084 { ::flatbuffers::ET_ULONG, 0, 12 },
4085 { ::flatbuffers::ET_FLOAT, 0, -1 },
4086 { ::flatbuffers::ET_FLOAT, 0, -1 },
4087 { ::flatbuffers::ET_FLOAT, 0, -1 },
4088 { ::flatbuffers::ET_FLOAT, 0, -1 },
4089 { ::flatbuffers::ET_FLOAT, 0, -1 },
4090 { ::flatbuffers::ET_FLOAT, 0, -1 },
4091 { ::flatbuffers::ET_FLOAT, 0, -1 },
4092 { ::flatbuffers::ET_DOUBLE, 0, -1 }
4093 };
4094 static const ::flatbuffers::TypeFunction type_refs[] = {
4095 MyGame::Example::Vec3TypeTable,
4096 MyGame::Example::ColorTypeTable,
4097 MyGame::Example::AnyTypeTable,
4098 MyGame::Example::TestTypeTable,
4099 MyGame::Example::MonsterTypeTable,
4100 MyGame::Example::StatTypeTable,
4101 MyGame::Example::AbilityTypeTable,
4102 MyGame::InParentNamespaceTypeTable,
4103 MyGame::Example::ReferrableTypeTable,
4104 MyGame::Example::AnyUniqueAliasesTypeTable,
4105 MyGame::Example::AnyAmbiguousAliasesTypeTable,
4106 MyGame::Example::RaceTypeTable,
4107 MyGame::Example::LongEnumTypeTable
4108 };
4109 static const char * const names[] = {
4110 "pos",
4111 "mana",
4112 "hp",
4113 "name",
4114 "friendly",
4115 "inventory",
4116 "color",
4117 "test_type",
4118 "test",
4119 "test4",
4120 "testarrayofstring",
4121 "testarrayoftables",
4122 "enemy",
4123 "testnestedflatbuffer",
4124 "testempty",
4125 "testbool",
4126 "testhashs32_fnv1",
4127 "testhashu32_fnv1",
4128 "testhashs64_fnv1",
4129 "testhashu64_fnv1",
4130 "testhashs32_fnv1a",
4131 "testhashu32_fnv1a",
4132 "testhashs64_fnv1a",
4133 "testhashu64_fnv1a",
4134 "testarrayofbools",
4135 "testf",
4136 "testf2",
4137 "testf3",
4138 "testarrayofstring2",
4139 "testarrayofsortedstruct",
4140 "flex",
4141 "test5",
4142 "vector_of_longs",
4143 "vector_of_doubles",
4144 "parent_namespace_test",
4145 "vector_of_referrables",
4146 "single_weak_reference",
4147 "vector_of_weak_references",
4148 "vector_of_strong_referrables",
4149 "co_owning_reference",
4150 "vector_of_co_owning_references",
4151 "non_owning_reference",
4152 "vector_of_non_owning_references",
4153 "any_unique_type",
4154 "any_unique",
4155 "any_ambiguous_type",
4156 "any_ambiguous",
4157 "vector_of_enums",
4158 "signed_enum",
4159 "testrequirednestedflatbuffer",
4160 "scalar_key_sorted_tables",
4161 "native_inline",
4162 "long_enum_non_enum_default",
4163 "long_enum_normal_default",
4164 "nan_default",
4165 "inf_default",
4166 "positive_inf_default",
4167 "infinity_default",
4168 "positive_infinity_default",
4169 "negative_inf_default",
4170 "negative_infinity_default",
4171 "double_inf_default"
4172 };
4173 static const ::flatbuffers::TypeTable tt = {
4174 ::flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
4175 };
4176 return &tt;
4177 }
4178
4179 inline const ::flatbuffers::TypeTable *TypeAliasesTypeTable() {
4180 static const ::flatbuffers::TypeCode type_codes[] = {
4181 { ::flatbuffers::ET_CHAR, 0, -1 },
4182 { ::flatbuffers::ET_UCHAR, 0, -1 },
4183 { ::flatbuffers::ET_SHORT, 0, -1 },
4184 { ::flatbuffers::ET_USHORT, 0, -1 },
4185 { ::flatbuffers::ET_INT, 0, -1 },
4186 { ::flatbuffers::ET_UINT, 0, -1 },
4187 { ::flatbuffers::ET_LONG, 0, -1 },
4188 { ::flatbuffers::ET_ULONG, 0, -1 },
4189 { ::flatbuffers::ET_FLOAT, 0, -1 },
4190 { ::flatbuffers::ET_DOUBLE, 0, -1 },
4191 { ::flatbuffers::ET_CHAR, 1, -1 },
4192 { ::flatbuffers::ET_DOUBLE, 1, -1 }
4193 };
4194 static const char * const names[] = {
4195 "i8",
4196 "u8",
4197 "i16",
4198 "u16",
4199 "i32",
4200 "u32",
4201 "i64",
4202 "u64",
4203 "f32",
4204 "f64",
4205 "v8",
4206 "vf64"
4207 };
4208 static const ::flatbuffers::TypeTable tt = {
4209 ::flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, nullptr, names
4210 };
4211 return &tt;
4212 }
4213
4214 inline const MyGame::Example::Monster *GetMonster(const void *buf) {
4215 return ::flatbuffers::GetRoot<MyGame::Example::Monster>(buf);
4216 }
4217
4218 inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) {
4219 return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::Monster>(buf);
4220 }
4221
4222 inline Monster *GetMutableMonster(void *buf) {
4223 return ::flatbuffers::GetMutableRoot<Monster>(buf);
4224 }
4225
4226 inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) {
4227 return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::Monster>(buf);
4228 }
4229
4230 inline const char *MonsterIdentifier() {
4231 return "MONS";
4232 }
4233
4234 inline bool MonsterBufferHasIdentifier(const void *buf) {
4235 return ::flatbuffers::BufferHasIdentifier(
4236 buf, MonsterIdentifier());
4237 }
4238
4239 inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
4240 return ::flatbuffers::BufferHasIdentifier(
4241 buf, MonsterIdentifier(), true);
4242 }
4243
4244 inline bool VerifyMonsterBuffer(
4245 ::flatbuffers::Verifier &verifier) {
4246 return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
4247 }
4248
4249 inline bool VerifySizePrefixedMonsterBuffer(
4250 ::flatbuffers::Verifier &verifier) {
4251 return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
4252 }
4253
4254 inline const char *MonsterExtension() {
4255 return "mon";
4256 }
4257
4258 inline void FinishMonsterBuffer(
4259 ::flatbuffers::FlatBufferBuilder &fbb,
4260 ::flatbuffers::Offset<MyGame::Example::Monster> root) {
4261 fbb.Finish(root, MonsterIdentifier());
4262 }
4263
4264 inline void FinishSizePrefixedMonsterBuffer(
4265 ::flatbuffers::FlatBufferBuilder &fbb,
4266 ::flatbuffers::Offset<MyGame::Example::Monster> root) {
4267 fbb.FinishSizePrefixed(root, MonsterIdentifier());
4268 }
4269
4270 inline std::unique_ptr<MyGame::Example::MonsterT> UnPackMonster(
4271 const void *buf,
4272 const ::flatbuffers::resolver_function_t *res = nullptr) {
4273 return std::unique_ptr<MyGame::Example::MonsterT>(GetMonster(buf)->UnPack(res));
4274 }
4275
4276 inline std::unique_ptr<MyGame::Example::MonsterT> UnPackSizePrefixedMonster(
4277 const void *buf,
4278 const ::flatbuffers::resolver_function_t *res = nullptr) {
4279 return std::unique_ptr<MyGame::Example::MonsterT>(GetSizePrefixedMonster(buf)->UnPack(res));
4280 }
4281
4282 } // namespace Example
4283 } // namespace MyGame
4284
4285 #endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
4286