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.
13static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
14 FLATBUFFERS_VERSION_MINOR == 5 &&
15 FLATBUFFERS_VERSION_REVISION == 26,
16 "Non-compatible flatbuffers version included");
17
18namespace MyGame {
19
20struct InParentNamespace;
21struct InParentNamespaceBuilder;
22struct InParentNamespaceT;
23
24namespace Example2 {
25
26struct Monster;
27struct MonsterBuilder;
28struct MonsterT;
29
30} // namespace Example2
31
32namespace Example {
33
34struct Test;
35
36struct TestSimpleTableWithEnum;
37struct TestSimpleTableWithEnumBuilder;
38struct TestSimpleTableWithEnumT;
39
40struct Vec3;
41
42struct Ability;
43
44struct StructOfStructs;
45
46struct StructOfStructsOfStructs;
47
48struct Stat;
49struct StatBuilder;
50struct StatT;
51
52struct Referrable;
53struct ReferrableBuilder;
54struct ReferrableT;
55
56struct Monster;
57struct MonsterBuilder;
58struct MonsterT;
59
60struct TypeAliases;
61struct TypeAliasesBuilder;
62struct TypeAliasesT;
63
64} // namespace Example
65
66inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable();
67
68namespace Example2 {
69
70inline const ::flatbuffers::TypeTable *MonsterTypeTable();
71
72} // namespace Example2
73
74namespace Example {
75
76inline const ::flatbuffers::TypeTable *TestTypeTable();
77
78inline const ::flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable();
79
80inline const ::flatbuffers::TypeTable *Vec3TypeTable();
81
82inline const ::flatbuffers::TypeTable *AbilityTypeTable();
83
84inline const ::flatbuffers::TypeTable *StructOfStructsTypeTable();
85
86inline const ::flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable();
87
88inline const ::flatbuffers::TypeTable *StatTypeTable();
89
90inline const ::flatbuffers::TypeTable *ReferrableTypeTable();
91
92inline const ::flatbuffers::TypeTable *MonsterTypeTable();
93
94inline const ::flatbuffers::TypeTable *TypeAliasesTypeTable();
95
96/// Composite components of Monster color.
97enum 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};
107FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Color, uint8_t)
108
109inline const Color (&EnumValuesColor())[3] {
110 static const Color values[] = {
111 Color::Red,
112 Color::Green,
113 Color::Blue
114 };
115 return values;
116}
117
118inline 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
133inline 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
139enum class Race : int8_t {
140 None = -1,
141 Human = 0,
142 Dwarf = 1,
143 Elf = 2,
144 MIN = None,
145 MAX = Elf
146};
147
148inline 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
158inline 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
169inline 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
175enum class LongEnum : uint64_t {
176 LongOne = 2ULL,
177 LongTwo = 4ULL,
178 LongBig = 1099511627776ULL,
179 NONE = 0,
180 ANY = 1099511627782ULL
181};
182FLATBUFFERS_DEFINE_BITMASK_OPERATORS(LongEnum, uint64_t)
183
184inline const LongEnum (&EnumValuesLongEnum())[3] {
185 static const LongEnum values[] = {
186 LongEnum::LongOne,
187 LongEnum::LongTwo,
188 LongEnum::LongBig
189 };
190 return values;
191}
192
193inline 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
202enum 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
211inline 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
221inline 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
232inline 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
238template<typename T> struct AnyTraits {
239 static const Any enum_value = Any::NONE;
240};
241
242template<> struct AnyTraits<MyGame::Example::Monster> {
243 static const Any enum_value = Any::Monster;
244};
245
246template<> struct AnyTraits<MyGame::Example::TestSimpleTableWithEnum> {
247 static const Any enum_value = Any::TestSimpleTableWithEnum;
248};
249
250template<> struct AnyTraits<MyGame::Example2::Monster> {
251 static const Any enum_value = Any::MyGame_Example2_Monster;
252};
253
254template<typename T> struct AnyUnionTraits {
255 static const Any enum_value = Any::NONE;
256};
257
258template<> struct AnyUnionTraits<MyGame::Example::MonsterT> {
259 static const Any enum_value = Any::Monster;
260};
261
262template<> struct AnyUnionTraits<MyGame::Example::TestSimpleTableWithEnumT> {
263 static const Any enum_value = Any::TestSimpleTableWithEnum;
264};
265
266template<> struct AnyUnionTraits<MyGame::Example2::MonsterT> {
267 static const Any enum_value = Any::MyGame_Example2_Monster;
268};
269
270struct 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
326bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
327bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
328
329enum class AnyUniqueAliases : uint8_t {
330 NONE = 0,
331 M = 1,
332 TS = 2,
333 M2 = 3,
334 MIN = NONE,
335 MAX = M2
336};
337
338inline 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
348inline 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
359inline 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
365template<typename T> struct AnyUniqueAliasesTraits {
366 static const AnyUniqueAliases enum_value = AnyUniqueAliases::NONE;
367};
368
369template<> struct AnyUniqueAliasesTraits<MyGame::Example::Monster> {
370 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M;
371};
372
373template<> struct AnyUniqueAliasesTraits<MyGame::Example::TestSimpleTableWithEnum> {
374 static const AnyUniqueAliases enum_value = AnyUniqueAliases::TS;
375};
376
377template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> {
378 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M2;
379};
380
381template<typename T> struct AnyUniqueAliasesUnionTraits {
382 static const AnyUniqueAliases enum_value = AnyUniqueAliases::NONE;
383};
384
385template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example::MonsterT> {
386 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M;
387};
388
389template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example::TestSimpleTableWithEnumT> {
390 static const AnyUniqueAliases enum_value = AnyUniqueAliases::TS;
391};
392
393template<> struct AnyUniqueAliasesUnionTraits<MyGame::Example2::MonsterT> {
394 static const AnyUniqueAliases enum_value = AnyUniqueAliases::M2;
395};
396
397struct 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
453bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
454bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
455
456enum class AnyAmbiguousAliases : uint8_t {
457 NONE = 0,
458 M1 = 1,
459 M2 = 2,
460 M3 = 3,
461 MIN = NONE,
462 MAX = M3
463};
464
465inline 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
475inline 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
486inline 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
492struct 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
538bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
539bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
540
541FLATBUFFERS_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 != Index, "Invalid Field Index");
581 }
582};
583FLATBUFFERS_STRUCT_END(Test, 4);
584
585struct 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
598FLATBUFFERS_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 != Index, "Invalid Field Index");
688 }
689};
690FLATBUFFERS_STRUCT_END(Vec3, 32);
691
692struct 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
709FLATBUFFERS_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 != Index, "Invalid Field Index");
750 }
751};
752FLATBUFFERS_STRUCT_END(Ability, 8);
753
754struct 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
767FLATBUFFERS_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 != Index, "Invalid Field Index");
812 }
813};
814FLATBUFFERS_STRUCT_END(StructOfStructs, 20);
815
816struct 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
830FLATBUFFERS_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 != Index, "Invalid Field Index");
855 }
856};
857FLATBUFFERS_STRUCT_END(StructOfStructsOfStructs, 20);
858
859struct 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
873struct InParentNamespaceT : public ::flatbuffers::NativeTable {
874 typedef InParentNamespace TableType;
875};
876
877struct 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
893struct 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
908inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(
909 ::flatbuffers::FlatBufferBuilder &_fbb) {
910 InParentNamespaceBuilder builder_(_fbb);
911 return builder_.Finish();
912}
913
914struct 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
925namespace Example2 {
926
927struct MonsterT : public ::flatbuffers::NativeTable {
928 typedef Monster TableType;
929};
930
931struct 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
947struct 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
962inline ::flatbuffers::Offset<Monster> CreateMonster(
963 ::flatbuffers::FlatBufferBuilder &_fbb) {
964 MonsterBuilder builder_(_fbb);
965 return builder_.Finish();
966}
967
968struct 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
981namespace Example {
982
983struct TestSimpleTableWithEnumT : public ::flatbuffers::NativeTable {
984 typedef TestSimpleTableWithEnum TableType;
985 MyGame::Example::Color color = MyGame::Example::Color::Green;
986};
987
988struct 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 != Index, "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
1019struct 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
1037inline ::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
1045struct 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
1060struct StatT : public ::flatbuffers::NativeTable {
1061 typedef Stat TableType;
1062 std::string id{};
1063 int64_t val = 0;
1064 uint16_t count = 0;
1065};
1066
1067struct 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 != Index, "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
1123struct 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
1147inline ::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
1159struct 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
1174inline ::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
1189struct ReferrableT : public ::flatbuffers::NativeTable {
1190 typedef Referrable TableType;
1191 uint64_t id = 0;
1192};
1193
1194struct 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 != Index, "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
1231struct 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
1249inline ::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
1257struct 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
1272struct 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"
1339struct 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 const ::flatbuffers::Vector<uint8_t> *inventory() const {
1440 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1441 }
1442 ::flatbuffers::Vector<uint8_t> *mutable_inventory() {
1443 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1444 }
1445 MyGame::Example::Color color() const {
1446 return static_cast<MyGame::Example::Color>(GetField<uint8_t>(VT_COLOR, 8));
1447 }
1448 bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(8)) {
1449 return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 8);
1450 }
1451 MyGame::Example::Any test_type() const {
1452 return static_cast<MyGame::Example::Any>(GetField<uint8_t>(VT_TEST_TYPE, 0));
1453 }
1454 const void *test() const {
1455 return GetPointer<const void *>(VT_TEST);
1456 }
1457 template<typename T> const T *test_as() const;
1458 const MyGame::Example::Monster *test_as_Monster() const {
1459 return test_type() == MyGame::Example::Any::Monster ? static_cast<const MyGame::Example::Monster *>(test()) : nullptr;
1460 }
1461 const MyGame::Example::TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const {
1462 return test_type() == MyGame::Example::Any::TestSimpleTableWithEnum ? static_cast<const MyGame::Example::TestSimpleTableWithEnum *>(test()) : nullptr;
1463 }
1464 const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
1465 return test_type() == MyGame::Example::Any::MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
1466 }
1467 void *mutable_test() {
1468 return GetPointer<void *>(VT_TEST);
1469 }
1470 const ::flatbuffers::Vector<const MyGame::Example::Test *> *test4() const {
1471 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST4);
1472 }
1473 ::flatbuffers::Vector<const MyGame::Example::Test *> *mutable_test4() {
1474 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST4);
1475 }
1476 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring() const {
1477 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1478 }
1479 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_testarrayofstring() {
1480 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1481 }
1482 /// an example documentation comment: this will end up in the generated code
1483 /// multiline too
1484 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables() const {
1485 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *>(VT_TESTARRAYOFTABLES);
1486 }
1487 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *mutable_testarrayoftables() {
1488 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>> *>(VT_TESTARRAYOFTABLES);
1489 }
1490 const MyGame::Example::Monster *enemy() const {
1491 return GetPointer<const MyGame::Example::Monster *>(VT_ENEMY);
1492 }
1493 MyGame::Example::Monster *mutable_enemy() {
1494 return GetPointer<MyGame::Example::Monster *>(VT_ENEMY);
1495 }
1496 const ::flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const {
1497 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1498 }
1499 ::flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() {
1500 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1501 }
1502 const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const {
1503 const auto _f = testnestedflatbuffer();
1504 return _f ? ::flatbuffers::GetRoot<MyGame::Example::Monster>(_f->Data())
1505 : nullptr;
1506 }
1507 const MyGame::Example::Stat *testempty() const {
1508 return GetPointer<const MyGame::Example::Stat *>(VT_TESTEMPTY);
1509 }
1510 MyGame::Example::Stat *mutable_testempty() {
1511 return GetPointer<MyGame::Example::Stat *>(VT_TESTEMPTY);
1512 }
1513 bool testbool() const {
1514 return GetField<uint8_t>(VT_TESTBOOL, 0) != 0;
1515 }
1516 bool mutate_testbool(bool _testbool = 0) {
1517 return SetField<uint8_t>(VT_TESTBOOL, static_cast<uint8_t>(_testbool), 0);
1518 }
1519 int32_t testhashs32_fnv1() const {
1520 return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0);
1521 }
1522 bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1 = 0) {
1523 return SetField<int32_t>(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0);
1524 }
1525 uint32_t testhashu32_fnv1() const {
1526 return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0);
1527 }
1528 bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1 = 0) {
1529 return SetField<uint32_t>(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0);
1530 }
1531 int64_t testhashs64_fnv1() const {
1532 return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0);
1533 }
1534 bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1 = 0) {
1535 return SetField<int64_t>(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0);
1536 }
1537 uint64_t testhashu64_fnv1() const {
1538 return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0);
1539 }
1540 bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1 = 0) {
1541 return SetField<uint64_t>(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0);
1542 }
1543 int32_t testhashs32_fnv1a() const {
1544 return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0);
1545 }
1546 bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a = 0) {
1547 return SetField<int32_t>(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0);
1548 }
1549 uint32_t testhashu32_fnv1a() const {
1550 return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0);
1551 }
1552 bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a = 0) {
1553 return SetField<uint32_t>(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0);
1554 }
1555 int64_t testhashs64_fnv1a() const {
1556 return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0);
1557 }
1558 bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a = 0) {
1559 return SetField<int64_t>(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0);
1560 }
1561 uint64_t testhashu64_fnv1a() const {
1562 return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0);
1563 }
1564 bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a = 0) {
1565 return SetField<uint64_t>(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0);
1566 }
1567 const ::flatbuffers::Vector<uint8_t> *testarrayofbools() const {
1568 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1569 }
1570 ::flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() {
1571 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1572 }
1573 float testf() const {
1574 return GetField<float>(VT_TESTF, 3.14159f);
1575 }
1576 bool mutate_testf(float _testf = 3.14159f) {
1577 return SetField<float>(VT_TESTF, _testf, 3.14159f);
1578 }
1579 float testf2() const {
1580 return GetField<float>(VT_TESTF2, 3.0f);
1581 }
1582 bool mutate_testf2(float _testf2 = 3.0f) {
1583 return SetField<float>(VT_TESTF2, _testf2, 3.0f);
1584 }
1585 float testf3() const {
1586 return GetField<float>(VT_TESTF3, 0.0f);
1587 }
1588 bool mutate_testf3(float _testf3 = 0.0f) {
1589 return SetField<float>(VT_TESTF3, _testf3, 0.0f);
1590 }
1591 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2() const {
1592 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1593 }
1594 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_testarrayofstring2() {
1595 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1596 }
1597 const ::flatbuffers::Vector<const MyGame::Example::Ability *> *testarrayofsortedstruct() const {
1598 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1599 }
1600 ::flatbuffers::Vector<const MyGame::Example::Ability *> *mutable_testarrayofsortedstruct() {
1601 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1602 }
1603 const ::flatbuffers::Vector<uint8_t> *flex() const {
1604 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1605 }
1606 ::flatbuffers::Vector<uint8_t> *mutable_flex() {
1607 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1608 }
1609 flexbuffers::Reference flex_flexbuffer_root() const {
1610 const auto _f = flex();
1611 return _f ? flexbuffers::GetRoot(_f->Data(), _f->size())
1612 : flexbuffers::Reference();
1613 }
1614 const ::flatbuffers::Vector<const MyGame::Example::Test *> *test5() const {
1615 return GetPointer<const ::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST5);
1616 }
1617 ::flatbuffers::Vector<const MyGame::Example::Test *> *mutable_test5() {
1618 return GetPointer<::flatbuffers::Vector<const MyGame::Example::Test *> *>(VT_TEST5);
1619 }
1620 const ::flatbuffers::Vector<int64_t> *vector_of_longs() const {
1621 return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1622 }
1623 ::flatbuffers::Vector<int64_t> *mutable_vector_of_longs() {
1624 return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1625 }
1626 const ::flatbuffers::Vector<double> *vector_of_doubles() const {
1627 return GetPointer<const ::flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1628 }
1629 ::flatbuffers::Vector<double> *mutable_vector_of_doubles() {
1630 return GetPointer<::flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1631 }
1632 const MyGame::InParentNamespace *parent_namespace_test() const {
1633 return GetPointer<const MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1634 }
1635 MyGame::InParentNamespace *mutable_parent_namespace_test() {
1636 return GetPointer<MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1637 }
1638 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables() const {
1639 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1640 }
1641 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *mutable_vector_of_referrables() {
1642 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1643 }
1644 uint64_t single_weak_reference() const {
1645 return GetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, 0);
1646 }
1647 bool mutate_single_weak_reference(uint64_t _single_weak_reference = 0) {
1648 return SetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0);
1649 }
1650 const ::flatbuffers::Vector<uint64_t> *vector_of_weak_references() const {
1651 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1652 }
1653 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_weak_references() {
1654 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1655 }
1656 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables() const {
1657 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1658 }
1659 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *mutable_vector_of_strong_referrables() {
1660 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1661 }
1662 uint64_t co_owning_reference() const {
1663 return GetField<uint64_t>(VT_CO_OWNING_REFERENCE, 0);
1664 }
1665 bool mutate_co_owning_reference(uint64_t _co_owning_reference = 0) {
1666 return SetField<uint64_t>(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0);
1667 }
1668 const ::flatbuffers::Vector<uint64_t> *vector_of_co_owning_references() const {
1669 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1670 }
1671 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_co_owning_references() {
1672 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1673 }
1674 uint64_t non_owning_reference() const {
1675 return GetField<uint64_t>(VT_NON_OWNING_REFERENCE, 0);
1676 }
1677 bool mutate_non_owning_reference(uint64_t _non_owning_reference = 0) {
1678 return SetField<uint64_t>(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0);
1679 }
1680 const ::flatbuffers::Vector<uint64_t> *vector_of_non_owning_references() const {
1681 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1682 }
1683 ::flatbuffers::Vector<uint64_t> *mutable_vector_of_non_owning_references() {
1684 return GetPointer<::flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1685 }
1686 MyGame::Example::AnyUniqueAliases any_unique_type() const {
1687 return static_cast<MyGame::Example::AnyUniqueAliases>(GetField<uint8_t>(VT_ANY_UNIQUE_TYPE, 0));
1688 }
1689 const void *any_unique() const {
1690 return GetPointer<const void *>(VT_ANY_UNIQUE);
1691 }
1692 template<typename T> const T *any_unique_as() const;
1693 const MyGame::Example::Monster *any_unique_as_M() const {
1694 return any_unique_type() == MyGame::Example::AnyUniqueAliases::M ? static_cast<const MyGame::Example::Monster *>(any_unique()) : nullptr;
1695 }
1696 const MyGame::Example::TestSimpleTableWithEnum *any_unique_as_TS() const {
1697 return any_unique_type() == MyGame::Example::AnyUniqueAliases::TS ? static_cast<const MyGame::Example::TestSimpleTableWithEnum *>(any_unique()) : nullptr;
1698 }
1699 const MyGame::Example2::Monster *any_unique_as_M2() const {
1700 return any_unique_type() == MyGame::Example::AnyUniqueAliases::M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
1701 }
1702 void *mutable_any_unique() {
1703 return GetPointer<void *>(VT_ANY_UNIQUE);
1704 }
1705 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const {
1706 return static_cast<MyGame::Example::AnyAmbiguousAliases>(GetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, 0));
1707 }
1708 const void *any_ambiguous() const {
1709 return GetPointer<const void *>(VT_ANY_AMBIGUOUS);
1710 }
1711 const MyGame::Example::Monster *any_ambiguous_as_M1() const {
1712 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M1 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1713 }
1714 const MyGame::Example::Monster *any_ambiguous_as_M2() const {
1715 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M2 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1716 }
1717 const MyGame::Example::Monster *any_ambiguous_as_M3() const {
1718 return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
1719 }
1720 void *mutable_any_ambiguous() {
1721 return GetPointer<void *>(VT_ANY_AMBIGUOUS);
1722 }
1723 const ::flatbuffers::Vector<MyGame::Example::Color> *vector_of_enums() const {
1724 return GetPointer<const ::flatbuffers::Vector<MyGame::Example::Color> *>(VT_VECTOR_OF_ENUMS);
1725 }
1726 ::flatbuffers::Vector<MyGame::Example::Color> *mutable_vector_of_enums() {
1727 return GetPointer<::flatbuffers::Vector<MyGame::Example::Color> *>(VT_VECTOR_OF_ENUMS);
1728 }
1729 MyGame::Example::Race signed_enum() const {
1730 return static_cast<MyGame::Example::Race>(GetField<int8_t>(VT_SIGNED_ENUM, -1));
1731 }
1732 bool mutate_signed_enum(MyGame::Example::Race _signed_enum = static_cast<MyGame::Example::Race>(-1)) {
1733 return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
1734 }
1735 const ::flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
1736 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
1737 }
1738 ::flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
1739 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
1740 }
1741 const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
1742 const auto _f = testrequirednestedflatbuffer();
1743 return _f ? ::flatbuffers::GetRoot<MyGame::Example::Monster>(_f->Data())
1744 : nullptr;
1745 }
1746 const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables() const {
1747 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
1748 }
1749 ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *mutable_scalar_key_sorted_tables() {
1750 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>> *>(VT_SCALAR_KEY_SORTED_TABLES);
1751 }
1752 const MyGame::Example::Test *native_inline() const {
1753 return GetStruct<const MyGame::Example::Test *>(VT_NATIVE_INLINE);
1754 }
1755 MyGame::Example::Test *mutable_native_inline() {
1756 return GetStruct<MyGame::Example::Test *>(VT_NATIVE_INLINE);
1757 }
1758 MyGame::Example::LongEnum long_enum_non_enum_default() const {
1759 return static_cast<MyGame::Example::LongEnum>(GetField<uint64_t>(VT_LONG_ENUM_NON_ENUM_DEFAULT, 0));
1760 }
1761 bool mutate_long_enum_non_enum_default(MyGame::Example::LongEnum _long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0)) {
1762 return SetField<uint64_t>(VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast<uint64_t>(_long_enum_non_enum_default), 0);
1763 }
1764 MyGame::Example::LongEnum long_enum_normal_default() const {
1765 return static_cast<MyGame::Example::LongEnum>(GetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, 2ULL));
1766 }
1767 bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
1768 return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
1769 }
1770 float nan_default() const {
1771 return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
1772 }
1773 bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
1774 return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
1775 }
1776 float inf_default() const {
1777 return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
1778 }
1779 bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
1780 return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
1781 }
1782 float positive_inf_default() const {
1783 return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
1784 }
1785 bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
1786 return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
1787 }
1788 float infinity_default() const {
1789 return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
1790 }
1791 bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
1792 return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
1793 }
1794 float positive_infinity_default() const {
1795 return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
1796 }
1797 bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
1798 return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
1799 }
1800 float negative_inf_default() const {
1801 return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
1802 }
1803 bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
1804 return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
1805 }
1806 float negative_infinity_default() const {
1807 return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
1808 }
1809 bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
1810 return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
1811 }
1812 double double_inf_default() const {
1813 return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
1814 }
1815 bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
1816 return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
1817 }
1818 template<size_t Index>
1819 auto get_field() const {
1820 if constexpr (Index == 0) return pos();
1821 else if constexpr (Index == 1) return mana();
1822 else if constexpr (Index == 2) return hp();
1823 else if constexpr (Index == 3) return name();
1824 else if constexpr (Index == 4) return inventory();
1825 else if constexpr (Index == 5) return color();
1826 else if constexpr (Index == 6) return test_type();
1827 else if constexpr (Index == 7) return test();
1828 else if constexpr (Index == 8) return test4();
1829 else if constexpr (Index == 9) return testarrayofstring();
1830 else if constexpr (Index == 10) return testarrayoftables();
1831 else if constexpr (Index == 11) return enemy();
1832 else if constexpr (Index == 12) return testnestedflatbuffer();
1833 else if constexpr (Index == 13) return testempty();
1834 else if constexpr (Index == 14) return testbool();
1835 else if constexpr (Index == 15) return testhashs32_fnv1();
1836 else if constexpr (Index == 16) return testhashu32_fnv1();
1837 else if constexpr (Index == 17) return testhashs64_fnv1();
1838 else if constexpr (Index == 18) return testhashu64_fnv1();
1839 else if constexpr (Index == 19) return testhashs32_fnv1a();
1840 else if constexpr (Index == 20) return testhashu32_fnv1a();
1841 else if constexpr (Index == 21) return testhashs64_fnv1a();
1842 else if constexpr (Index == 22) return testhashu64_fnv1a();
1843 else if constexpr (Index == 23) return testarrayofbools();
1844 else if constexpr (Index == 24) return testf();
1845 else if constexpr (Index == 25) return testf2();
1846 else if constexpr (Index == 26) return testf3();
1847 else if constexpr (Index == 27) return testarrayofstring2();
1848 else if constexpr (Index == 28) return testarrayofsortedstruct();
1849 else if constexpr (Index == 29) return flex();
1850 else if constexpr (Index == 30) return test5();
1851 else if constexpr (Index == 31) return vector_of_longs();
1852 else if constexpr (Index == 32) return vector_of_doubles();
1853 else if constexpr (Index == 33) return parent_namespace_test();
1854 else if constexpr (Index == 34) return vector_of_referrables();
1855 else if constexpr (Index == 35) return single_weak_reference();
1856 else if constexpr (Index == 36) return vector_of_weak_references();
1857 else if constexpr (Index == 37) return vector_of_strong_referrables();
1858 else if constexpr (Index == 38) return co_owning_reference();
1859 else if constexpr (Index == 39) return vector_of_co_owning_references();
1860 else if constexpr (Index == 40) return non_owning_reference();
1861 else if constexpr (Index == 41) return vector_of_non_owning_references();
1862 else if constexpr (Index == 42) return any_unique_type();
1863 else if constexpr (Index == 43) return any_unique();
1864 else if constexpr (Index == 44) return any_ambiguous_type();
1865 else if constexpr (Index == 45) return any_ambiguous();
1866 else if constexpr (Index == 46) return vector_of_enums();
1867 else if constexpr (Index == 47) return signed_enum();
1868 else if constexpr (Index == 48) return testrequirednestedflatbuffer();
1869 else if constexpr (Index == 49) return scalar_key_sorted_tables();
1870 else if constexpr (Index == 50) return native_inline();
1871 else if constexpr (Index == 51) return long_enum_non_enum_default();
1872 else if constexpr (Index == 52) return long_enum_normal_default();
1873 else if constexpr (Index == 53) return nan_default();
1874 else if constexpr (Index == 54) return inf_default();
1875 else if constexpr (Index == 55) return positive_inf_default();
1876 else if constexpr (Index == 56) return infinity_default();
1877 else if constexpr (Index == 57) return positive_infinity_default();
1878 else if constexpr (Index == 58) return negative_inf_default();
1879 else if constexpr (Index == 59) return negative_infinity_default();
1880 else if constexpr (Index == 60) return double_inf_default();
1881 else static_assert(Index != Index, "Invalid Field Index");
1882 }
1883 bool Verify(::flatbuffers::Verifier &verifier) const {
1884 return VerifyTableStart(verifier) &&
1885 VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
1886 VerifyField<int16_t>(verifier, VT_MANA, 2) &&
1887 VerifyField<int16_t>(verifier, VT_HP, 2) &&
1888 VerifyOffsetRequired(verifier, VT_NAME) &&
1889 verifier.VerifyString(name()) &&
1890 VerifyOffset(verifier, VT_INVENTORY) &&
1891 verifier.VerifyVector(inventory()) &&
1892 VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
1893 VerifyField<uint8_t>(verifier, VT_TEST_TYPE, 1) &&
1894 VerifyOffset(verifier, VT_TEST) &&
1895 VerifyAny(verifier, test(), test_type()) &&
1896 VerifyOffset(verifier, VT_TEST4) &&
1897 verifier.VerifyVector(test4()) &&
1898 VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
1899 verifier.VerifyVector(testarrayofstring()) &&
1900 verifier.VerifyVectorOfStrings(testarrayofstring()) &&
1901 VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
1902 verifier.VerifyVector(testarrayoftables()) &&
1903 verifier.VerifyVectorOfTables(testarrayoftables()) &&
1904 VerifyOffset(verifier, VT_ENEMY) &&
1905 verifier.VerifyTable(enemy()) &&
1906 VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
1907 verifier.VerifyVector(testnestedflatbuffer()) &&
1908 verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
1909 VerifyOffset(verifier, VT_TESTEMPTY) &&
1910 verifier.VerifyTable(testempty()) &&
1911 VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
1912 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1, 4) &&
1913 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1, 4) &&
1914 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1, 8) &&
1915 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1, 8) &&
1916 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A, 4) &&
1917 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A, 4) &&
1918 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A, 8) &&
1919 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A, 8) &&
1920 VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
1921 verifier.VerifyVector(testarrayofbools()) &&
1922 VerifyField<float>(verifier, VT_TESTF, 4) &&
1923 VerifyField<float>(verifier, VT_TESTF2, 4) &&
1924 VerifyField<float>(verifier, VT_TESTF3, 4) &&
1925 VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
1926 verifier.VerifyVector(testarrayofstring2()) &&
1927 verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
1928 VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
1929 verifier.VerifyVector(testarrayofsortedstruct()) &&
1930 VerifyOffset(verifier, VT_FLEX) &&
1931 verifier.VerifyVector(flex()) &&
1932 flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) &&
1933 VerifyOffset(verifier, VT_TEST5) &&
1934 verifier.VerifyVector(test5()) &&
1935 VerifyOffset(verifier, VT_VECTOR_OF_LONGS) &&
1936 verifier.VerifyVector(vector_of_longs()) &&
1937 VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) &&
1938 verifier.VerifyVector(vector_of_doubles()) &&
1939 VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
1940 verifier.VerifyTable(parent_namespace_test()) &&
1941 VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
1942 verifier.VerifyVector(vector_of_referrables()) &&
1943 verifier.VerifyVectorOfTables(vector_of_referrables()) &&
1944 VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE, 8) &&
1945 VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
1946 verifier.VerifyVector(vector_of_weak_references()) &&
1947 VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
1948 verifier.VerifyVector(vector_of_strong_referrables()) &&
1949 verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
1950 VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE, 8) &&
1951 VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
1952 verifier.VerifyVector(vector_of_co_owning_references()) &&
1953 VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE, 8) &&
1954 VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
1955 verifier.VerifyVector(vector_of_non_owning_references()) &&
1956 VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE, 1) &&
1957 VerifyOffset(verifier, VT_ANY_UNIQUE) &&
1958 VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
1959 VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) &&
1960 VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
1961 VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
1962 VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
1963 verifier.VerifyVector(vector_of_enums()) &&
1964 VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
1965 VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
1966 verifier.VerifyVector(testrequirednestedflatbuffer()) &&
1967 verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
1968 VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
1969 verifier.VerifyVector(scalar_key_sorted_tables()) &&
1970 verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
1971 VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
1972 VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
1973 VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
1974 VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
1975 VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
1976 VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
1977 VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
1978 VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
1979 VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
1980 VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
1981 VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
1982 verifier.EndTable();
1983 }
1984 MonsterT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1985 void UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
1986 static ::flatbuffers::Offset<Monster> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
1987};
1988
1989template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Example::Monster>() const {
1990 return test_as_Monster();
1991}
1992
1993template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
1994 return test_as_TestSimpleTableWithEnum();
1995}
1996
1997template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
1998 return test_as_MyGame_Example2_Monster();
1999}
2000
2001template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
2002 return any_unique_as_M();
2003}
2004
2005template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
2006 return any_unique_as_TS();
2007}
2008
2009template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
2010 return any_unique_as_M2();
2011}
2012
2013struct MonsterBuilder {
2014 typedef Monster Table;
2015 ::flatbuffers::FlatBufferBuilder &fbb_;
2016 ::flatbuffers::uoffset_t start_;
2017 void add_pos(const MyGame::Example::Vec3 *pos) {
2018 fbb_.AddStruct(Monster::VT_POS, pos);
2019 }
2020 void add_mana(int16_t mana) {
2021 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
2022 }
2023 void add_hp(int16_t hp) {
2024 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
2025 }
2026 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
2027 fbb_.AddOffset(Monster::VT_NAME, name);
2028 }
2029 void add_inventory(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory) {
2030 fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
2031 }
2032 void add_color(MyGame::Example::Color color) {
2033 fbb_.AddElement<uint8_t>(Monster::VT_COLOR, static_cast<uint8_t>(color), 8);
2034 }
2035 void add_test_type(MyGame::Example::Any test_type) {
2036 fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0);
2037 }
2038 void add_test(::flatbuffers::Offset<void> test) {
2039 fbb_.AddOffset(Monster::VT_TEST, test);
2040 }
2041 void add_test4(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test4) {
2042 fbb_.AddOffset(Monster::VT_TEST4, test4);
2043 }
2044 void add_testarrayofstring(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring) {
2045 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring);
2046 }
2047 void add_testarrayoftables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>>> testarrayoftables) {
2048 fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables);
2049 }
2050 void add_enemy(::flatbuffers::Offset<MyGame::Example::Monster> enemy) {
2051 fbb_.AddOffset(Monster::VT_ENEMY, enemy);
2052 }
2053 void add_testnestedflatbuffer(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testnestedflatbuffer) {
2054 fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer);
2055 }
2056 void add_testempty(::flatbuffers::Offset<MyGame::Example::Stat> testempty) {
2057 fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty);
2058 }
2059 void add_testbool(bool testbool) {
2060 fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0);
2061 }
2062 void add_testhashs32_fnv1(int32_t testhashs32_fnv1) {
2063 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0);
2064 }
2065 void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) {
2066 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0);
2067 }
2068 void add_testhashs64_fnv1(int64_t testhashs64_fnv1) {
2069 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0);
2070 }
2071 void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) {
2072 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0);
2073 }
2074 void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) {
2075 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0);
2076 }
2077 void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) {
2078 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0);
2079 }
2080 void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) {
2081 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0);
2082 }
2083 void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) {
2084 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0);
2085 }
2086 void add_testarrayofbools(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testarrayofbools) {
2087 fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools);
2088 }
2089 void add_testf(float testf) {
2090 fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f);
2091 }
2092 void add_testf2(float testf2) {
2093 fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f);
2094 }
2095 void add_testf3(float testf3) {
2096 fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f);
2097 }
2098 void add_testarrayofstring2(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring2) {
2099 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2);
2100 }
2101 void add_testarrayofsortedstruct(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Ability *>> testarrayofsortedstruct) {
2102 fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct);
2103 }
2104 void add_flex(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> flex) {
2105 fbb_.AddOffset(Monster::VT_FLEX, flex);
2106 }
2107 void add_test5(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test5) {
2108 fbb_.AddOffset(Monster::VT_TEST5, test5);
2109 }
2110 void add_vector_of_longs(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> vector_of_longs) {
2111 fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs);
2112 }
2113 void add_vector_of_doubles(::flatbuffers::Offset<::flatbuffers::Vector<double>> vector_of_doubles) {
2114 fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles);
2115 }
2116 void add_parent_namespace_test(::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test) {
2117 fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test);
2118 }
2119 void add_vector_of_referrables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_referrables) {
2120 fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables);
2121 }
2122 void add_single_weak_reference(uint64_t single_weak_reference) {
2123 fbb_.AddElement<uint64_t>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0);
2124 }
2125 void add_vector_of_weak_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_weak_references) {
2126 fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references);
2127 }
2128 void add_vector_of_strong_referrables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_strong_referrables) {
2129 fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables);
2130 }
2131 void add_co_owning_reference(uint64_t co_owning_reference) {
2132 fbb_.AddElement<uint64_t>(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0);
2133 }
2134 void add_vector_of_co_owning_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_co_owning_references) {
2135 fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references);
2136 }
2137 void add_non_owning_reference(uint64_t non_owning_reference) {
2138 fbb_.AddElement<uint64_t>(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0);
2139 }
2140 void add_vector_of_non_owning_references(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_non_owning_references) {
2141 fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references);
2142 }
2143 void add_any_unique_type(MyGame::Example::AnyUniqueAliases any_unique_type) {
2144 fbb_.AddElement<uint8_t>(Monster::VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(any_unique_type), 0);
2145 }
2146 void add_any_unique(::flatbuffers::Offset<void> any_unique) {
2147 fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique);
2148 }
2149 void add_any_ambiguous_type(MyGame::Example::AnyAmbiguousAliases any_ambiguous_type) {
2150 fbb_.AddElement<uint8_t>(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(any_ambiguous_type), 0);
2151 }
2152 void add_any_ambiguous(::flatbuffers::Offset<void> any_ambiguous) {
2153 fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
2154 }
2155 void add_vector_of_enums(::flatbuffers::Offset<::flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums) {
2156 fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
2157 }
2158 void add_signed_enum(MyGame::Example::Race signed_enum) {
2159 fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
2160 }
2161 void add_testrequirednestedflatbuffer(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
2162 fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
2163 }
2164 void add_scalar_key_sorted_tables(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables) {
2165 fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables);
2166 }
2167 void add_native_inline(const MyGame::Example::Test *native_inline) {
2168 fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline);
2169 }
2170 void add_long_enum_non_enum_default(MyGame::Example::LongEnum long_enum_non_enum_default) {
2171 fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast<uint64_t>(long_enum_non_enum_default), 0);
2172 }
2173 void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
2174 fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
2175 }
2176 void add_nan_default(float nan_default) {
2177 fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
2178 }
2179 void add_inf_default(float inf_default) {
2180 fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
2181 }
2182 void add_positive_inf_default(float positive_inf_default) {
2183 fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
2184 }
2185 void add_infinity_default(float infinity_default) {
2186 fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
2187 }
2188 void add_positive_infinity_default(float positive_infinity_default) {
2189 fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
2190 }
2191 void add_negative_inf_default(float negative_inf_default) {
2192 fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
2193 }
2194 void add_negative_infinity_default(float negative_infinity_default) {
2195 fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
2196 }
2197 void add_double_inf_default(double double_inf_default) {
2198 fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
2199 }
2200 explicit MonsterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2201 : fbb_(_fbb) {
2202 start_ = fbb_.StartTable();
2203 }
2204 ::flatbuffers::Offset<Monster> Finish() {
2205 const auto end = fbb_.EndTable(start_);
2206 auto o = ::flatbuffers::Offset<Monster>(end);
2207 fbb_.Required(o, Monster::VT_NAME);
2208 return o;
2209 }
2210};
2211
2212inline ::flatbuffers::Offset<Monster> CreateMonster(
2213 ::flatbuffers::FlatBufferBuilder &_fbb,
2214 const MyGame::Example::Vec3 *pos = nullptr,
2215 int16_t mana = 150,
2216 int16_t hp = 100,
2217 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
2218 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory = 0,
2219 MyGame::Example::Color color = MyGame::Example::Color::Blue,
2220 MyGame::Example::Any test_type = MyGame::Example::Any::NONE,
2221 ::flatbuffers::Offset<void> test = 0,
2222 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test4 = 0,
2223 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring = 0,
2224 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>>> testarrayoftables = 0,
2225 ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
2226 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
2227 ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
2228 bool testbool = false,
2229 int32_t testhashs32_fnv1 = 0,
2230 uint32_t testhashu32_fnv1 = 0,
2231 int64_t testhashs64_fnv1 = 0,
2232 uint64_t testhashu64_fnv1 = 0,
2233 int32_t testhashs32_fnv1a = 0,
2234 uint32_t testhashu32_fnv1a = 0,
2235 int64_t testhashs64_fnv1a = 0,
2236 uint64_t testhashu64_fnv1a = 0,
2237 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testarrayofbools = 0,
2238 float testf = 3.14159f,
2239 float testf2 = 3.0f,
2240 float testf3 = 0.0f,
2241 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring2 = 0,
2242 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Ability *>> testarrayofsortedstruct = 0,
2243 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> flex = 0,
2244 ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test5 = 0,
2245 ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> vector_of_longs = 0,
2246 ::flatbuffers::Offset<::flatbuffers::Vector<double>> vector_of_doubles = 0,
2247 ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
2248 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_referrables = 0,
2249 uint64_t single_weak_reference = 0,
2250 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0,
2251 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_strong_referrables = 0,
2252 uint64_t co_owning_reference = 0,
2253 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_co_owning_references = 0,
2254 uint64_t non_owning_reference = 0,
2255 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_non_owning_references = 0,
2256 MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases::NONE,
2257 ::flatbuffers::Offset<void> any_unique = 0,
2258 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
2259 ::flatbuffers::Offset<void> any_ambiguous = 0,
2260 ::flatbuffers::Offset<::flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums = 0,
2261 MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
2262 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0,
2263 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
2264 const MyGame::Example::Test *native_inline = nullptr,
2265 MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
2266 MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
2267 float nan_default = std::numeric_limits<float>::quiet_NaN(),
2268 float inf_default = std::numeric_limits<float>::infinity(),
2269 float positive_inf_default = std::numeric_limits<float>::infinity(),
2270 float infinity_default = std::numeric_limits<float>::infinity(),
2271 float positive_infinity_default = std::numeric_limits<float>::infinity(),
2272 float negative_inf_default = -std::numeric_limits<float>::infinity(),
2273 float negative_infinity_default = -std::numeric_limits<float>::infinity(),
2274 double double_inf_default = std::numeric_limits<double>::infinity()) {
2275 MonsterBuilder builder_(_fbb);
2276 builder_.add_double_inf_default(double_inf_default);
2277 builder_.add_long_enum_normal_default(long_enum_normal_default);
2278 builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
2279 builder_.add_non_owning_reference(non_owning_reference);
2280 builder_.add_co_owning_reference(co_owning_reference);
2281 builder_.add_single_weak_reference(single_weak_reference);
2282 builder_.add_testhashu64_fnv1a(testhashu64_fnv1a);
2283 builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
2284 builder_.add_testhashu64_fnv1(testhashu64_fnv1);
2285 builder_.add_testhashs64_fnv1(testhashs64_fnv1);
2286 builder_.add_negative_infinity_default(negative_infinity_default);
2287 builder_.add_negative_inf_default(negative_inf_default);
2288 builder_.add_positive_infinity_default(positive_infinity_default);
2289 builder_.add_infinity_default(infinity_default);
2290 builder_.add_positive_inf_default(positive_inf_default);
2291 builder_.add_inf_default(inf_default);
2292 builder_.add_nan_default(nan_default);
2293 builder_.add_native_inline(native_inline);
2294 builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
2295 builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
2296 builder_.add_vector_of_enums(vector_of_enums);
2297 builder_.add_any_ambiguous(any_ambiguous);
2298 builder_.add_any_unique(any_unique);
2299 builder_.add_vector_of_non_owning_references(vector_of_non_owning_references);
2300 builder_.add_vector_of_co_owning_references(vector_of_co_owning_references);
2301 builder_.add_vector_of_strong_referrables(vector_of_strong_referrables);
2302 builder_.add_vector_of_weak_references(vector_of_weak_references);
2303 builder_.add_vector_of_referrables(vector_of_referrables);
2304 builder_.add_parent_namespace_test(parent_namespace_test);
2305 builder_.add_vector_of_doubles(vector_of_doubles);
2306 builder_.add_vector_of_longs(vector_of_longs);
2307 builder_.add_test5(test5);
2308 builder_.add_flex(flex);
2309 builder_.add_testarrayofsortedstruct(testarrayofsortedstruct);
2310 builder_.add_testarrayofstring2(testarrayofstring2);
2311 builder_.add_testf3(testf3);
2312 builder_.add_testf2(testf2);
2313 builder_.add_testf(testf);
2314 builder_.add_testarrayofbools(testarrayofbools);
2315 builder_.add_testhashu32_fnv1a(testhashu32_fnv1a);
2316 builder_.add_testhashs32_fnv1a(testhashs32_fnv1a);
2317 builder_.add_testhashu32_fnv1(testhashu32_fnv1);
2318 builder_.add_testhashs32_fnv1(testhashs32_fnv1);
2319 builder_.add_testempty(testempty);
2320 builder_.add_testnestedflatbuffer(testnestedflatbuffer);
2321 builder_.add_enemy(enemy);
2322 builder_.add_testarrayoftables(testarrayoftables);
2323 builder_.add_testarrayofstring(testarrayofstring);
2324 builder_.add_test4(test4);
2325 builder_.add_test(test);
2326 builder_.add_inventory(inventory);
2327 builder_.add_name(name);
2328 builder_.add_pos(pos);
2329 builder_.add_hp(hp);
2330 builder_.add_mana(mana);
2331 builder_.add_signed_enum(signed_enum);
2332 builder_.add_any_ambiguous_type(any_ambiguous_type);
2333 builder_.add_any_unique_type(any_unique_type);
2334 builder_.add_testbool(testbool);
2335 builder_.add_test_type(test_type);
2336 builder_.add_color(color);
2337 return builder_.Finish();
2338}
2339
2340struct Monster::Traits {
2341 using type = Monster;
2342 static auto constexpr Create = CreateMonster;
2343 static constexpr auto name = "Monster";
2344 static constexpr auto fully_qualified_name = "MyGame.Example.Monster";
2345 static constexpr size_t fields_number = 61;
2346 static constexpr std::array<const char *, fields_number> field_names = {
2347 "pos",
2348 "mana",
2349 "hp",
2350 "name",
2351 "inventory",
2352 "color",
2353 "test_type",
2354 "test",
2355 "test4",
2356 "testarrayofstring",
2357 "testarrayoftables",
2358 "enemy",
2359 "testnestedflatbuffer",
2360 "testempty",
2361 "testbool",
2362 "testhashs32_fnv1",
2363 "testhashu32_fnv1",
2364 "testhashs64_fnv1",
2365 "testhashu64_fnv1",
2366 "testhashs32_fnv1a",
2367 "testhashu32_fnv1a",
2368 "testhashs64_fnv1a",
2369 "testhashu64_fnv1a",
2370 "testarrayofbools",
2371 "testf",
2372 "testf2",
2373 "testf3",
2374 "testarrayofstring2",
2375 "testarrayofsortedstruct",
2376 "flex",
2377 "test5",
2378 "vector_of_longs",
2379 "vector_of_doubles",
2380 "parent_namespace_test",
2381 "vector_of_referrables",
2382 "single_weak_reference",
2383 "vector_of_weak_references",
2384 "vector_of_strong_referrables",
2385 "co_owning_reference",
2386 "vector_of_co_owning_references",
2387 "non_owning_reference",
2388 "vector_of_non_owning_references",
2389 "any_unique_type",
2390 "any_unique",
2391 "any_ambiguous_type",
2392 "any_ambiguous",
2393 "vector_of_enums",
2394 "signed_enum",
2395 "testrequirednestedflatbuffer",
2396 "scalar_key_sorted_tables",
2397 "native_inline",
2398 "long_enum_non_enum_default",
2399 "long_enum_normal_default",
2400 "nan_default",
2401 "inf_default",
2402 "positive_inf_default",
2403 "infinity_default",
2404 "positive_infinity_default",
2405 "negative_inf_default",
2406 "negative_infinity_default",
2407 "double_inf_default"
2408 };
2409 template<size_t Index>
2410 using FieldType = decltype(std::declval<type>().get_field<Index>());
2411};
2412
2413inline ::flatbuffers::Offset<Monster> CreateMonsterDirect(
2414 ::flatbuffers::FlatBufferBuilder &_fbb,
2415 const MyGame::Example::Vec3 *pos = nullptr,
2416 int16_t mana = 150,
2417 int16_t hp = 100,
2418 const char *name = nullptr,
2419 const std::vector<uint8_t> *inventory = nullptr,
2420 MyGame::Example::Color color = MyGame::Example::Color::Blue,
2421 MyGame::Example::Any test_type = MyGame::Example::Any::NONE,
2422 ::flatbuffers::Offset<void> test = 0,
2423 const std::vector<MyGame::Example::Test> *test4 = nullptr,
2424 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring = nullptr,
2425 std::vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables = nullptr,
2426 ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
2427 const std::vector<uint8_t> *testnestedflatbuffer = nullptr,
2428 ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
2429 bool testbool = false,
2430 int32_t testhashs32_fnv1 = 0,
2431 uint32_t testhashu32_fnv1 = 0,
2432 int64_t testhashs64_fnv1 = 0,
2433 uint64_t testhashu64_fnv1 = 0,
2434 int32_t testhashs32_fnv1a = 0,
2435 uint32_t testhashu32_fnv1a = 0,
2436 int64_t testhashs64_fnv1a = 0,
2437 uint64_t testhashu64_fnv1a = 0,
2438 const std::vector<uint8_t> *testarrayofbools = nullptr,
2439 float testf = 3.14159f,
2440 float testf2 = 3.0f,
2441 float testf3 = 0.0f,
2442 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2 = nullptr,
2443 std::vector<MyGame::Example::Ability> *testarrayofsortedstruct = nullptr,
2444 const std::vector<uint8_t> *flex = nullptr,
2445 const std::vector<MyGame::Example::Test> *test5 = nullptr,
2446 const std::vector<int64_t> *vector_of_longs = nullptr,
2447 const std::vector<double> *vector_of_doubles = nullptr,
2448 ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
2449 std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables = nullptr,
2450 uint64_t single_weak_reference = 0,
2451 const std::vector<uint64_t> *vector_of_weak_references = nullptr,
2452 std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables = nullptr,
2453 uint64_t co_owning_reference = 0,
2454 const std::vector<uint64_t> *vector_of_co_owning_references = nullptr,
2455 uint64_t non_owning_reference = 0,
2456 const std::vector<uint64_t> *vector_of_non_owning_references = nullptr,
2457 MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases::NONE,
2458 ::flatbuffers::Offset<void> any_unique = 0,
2459 MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
2460 ::flatbuffers::Offset<void> any_ambiguous = 0,
2461 const std::vector<MyGame::Example::Color> *vector_of_enums = nullptr,
2462 MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
2463 const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr,
2464 std::vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
2465 const MyGame::Example::Test *native_inline = nullptr,
2466 MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
2467 MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
2468 float nan_default = std::numeric_limits<float>::quiet_NaN(),
2469 float inf_default = std::numeric_limits<float>::infinity(),
2470 float positive_inf_default = std::numeric_limits<float>::infinity(),
2471 float infinity_default = std::numeric_limits<float>::infinity(),
2472 float positive_infinity_default = std::numeric_limits<float>::infinity(),
2473 float negative_inf_default = -std::numeric_limits<float>::infinity(),
2474 float negative_infinity_default = -std::numeric_limits<float>::infinity(),
2475 double double_inf_default = std::numeric_limits<double>::infinity()) {
2476 auto name__ = name ? _fbb.CreateString(name) : 0;
2477 auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
2478 auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
2479 auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*testarrayofstring) : 0;
2480 auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Monster>(testarrayoftables) : 0;
2481 auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0;
2482 auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0;
2483 auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*testarrayofstring2) : 0;
2484 auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfSortedStructs<MyGame::Example::Ability>(testarrayofsortedstruct) : 0;
2485 auto flex__ = flex ? _fbb.CreateVector<uint8_t>(*flex) : 0;
2486 auto test5__ = test5 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test5) : 0;
2487 auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector<int64_t>(*vector_of_longs) : 0;
2488 auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector<double>(*vector_of_doubles) : 0;
2489 auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Referrable>(vector_of_referrables) : 0;
2490 auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector<uint64_t>(*vector_of_weak_references) : 0;
2491 auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Referrable>(vector_of_strong_referrables) : 0;
2492 auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
2493 auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
2494 auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<MyGame::Example::Color>(*vector_of_enums) : 0;
2495 auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
2496 auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables<MyGame::Example::Stat>(scalar_key_sorted_tables) : 0;
2497 return MyGame::Example::CreateMonster(
2498 _fbb,
2499 pos,
2500 mana,
2501 hp,
2502 name__,
2503 inventory__,
2504 color,
2505 test_type,
2506 test,
2507 test4__,
2508 testarrayofstring__,
2509 testarrayoftables__,
2510 enemy,
2511 testnestedflatbuffer__,
2512 testempty,
2513 testbool,
2514 testhashs32_fnv1,
2515 testhashu32_fnv1,
2516 testhashs64_fnv1,
2517 testhashu64_fnv1,
2518 testhashs32_fnv1a,
2519 testhashu32_fnv1a,
2520 testhashs64_fnv1a,
2521 testhashu64_fnv1a,
2522 testarrayofbools__,
2523 testf,
2524 testf2,
2525 testf3,
2526 testarrayofstring2__,
2527 testarrayofsortedstruct__,
2528 flex__,
2529 test5__,
2530 vector_of_longs__,
2531 vector_of_doubles__,
2532 parent_namespace_test,
2533 vector_of_referrables__,
2534 single_weak_reference,
2535 vector_of_weak_references__,
2536 vector_of_strong_referrables__,
2537 co_owning_reference,
2538 vector_of_co_owning_references__,
2539 non_owning_reference,
2540 vector_of_non_owning_references__,
2541 any_unique_type,
2542 any_unique,
2543 any_ambiguous_type,
2544 any_ambiguous,
2545 vector_of_enums__,
2546 signed_enum,
2547 testrequirednestedflatbuffer__,
2548 scalar_key_sorted_tables__,
2549 native_inline,
2550 long_enum_non_enum_default,
2551 long_enum_normal_default,
2552 nan_default,
2553 inf_default,
2554 positive_inf_default,
2555 infinity_default,
2556 positive_infinity_default,
2557 negative_inf_default,
2558 negative_infinity_default,
2559 double_inf_default);
2560}
2561
2562::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2563
2564struct TypeAliasesT : public ::flatbuffers::NativeTable {
2565 typedef TypeAliases TableType;
2566 int8_t i8 = 0;
2567 uint8_t u8 = 0;
2568 int16_t i16 = 0;
2569 uint16_t u16 = 0;
2570 int32_t i32 = 0;
2571 uint32_t u32 = 0;
2572 int64_t i64 = 0;
2573 uint64_t u64 = 0;
2574 float f32 = 0.0f;
2575 double f64 = 0.0;
2576 std::vector<int8_t> v8{};
2577 std::vector<double> vf64{};
2578};
2579
2580struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
2581 typedef TypeAliasesT NativeTableType;
2582 typedef TypeAliasesBuilder Builder;
2583 struct Traits;
2584 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
2585 return TypeAliasesTypeTable();
2586 }
2587 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2588 VT_I8 = 4,
2589 VT_U8 = 6,
2590 VT_I16 = 8,
2591 VT_U16 = 10,
2592 VT_I32 = 12,
2593 VT_U32 = 14,
2594 VT_I64 = 16,
2595 VT_U64 = 18,
2596 VT_F32 = 20,
2597 VT_F64 = 22,
2598 VT_V8 = 24,
2599 VT_VF64 = 26
2600 };
2601 int8_t i8() const {
2602 return GetField<int8_t>(VT_I8, 0);
2603 }
2604 bool mutate_i8(int8_t _i8 = 0) {
2605 return SetField<int8_t>(VT_I8, _i8, 0);
2606 }
2607 uint8_t u8() const {
2608 return GetField<uint8_t>(VT_U8, 0);
2609 }
2610 bool mutate_u8(uint8_t _u8 = 0) {
2611 return SetField<uint8_t>(VT_U8, _u8, 0);
2612 }
2613 int16_t i16() const {
2614 return GetField<int16_t>(VT_I16, 0);
2615 }
2616 bool mutate_i16(int16_t _i16 = 0) {
2617 return SetField<int16_t>(VT_I16, _i16, 0);
2618 }
2619 uint16_t u16() const {
2620 return GetField<uint16_t>(VT_U16, 0);
2621 }
2622 bool mutate_u16(uint16_t _u16 = 0) {
2623 return SetField<uint16_t>(VT_U16, _u16, 0);
2624 }
2625 int32_t i32() const {
2626 return GetField<int32_t>(VT_I32, 0);
2627 }
2628 bool mutate_i32(int32_t _i32 = 0) {
2629 return SetField<int32_t>(VT_I32, _i32, 0);
2630 }
2631 uint32_t u32() const {
2632 return GetField<uint32_t>(VT_U32, 0);
2633 }
2634 bool mutate_u32(uint32_t _u32 = 0) {
2635 return SetField<uint32_t>(VT_U32, _u32, 0);
2636 }
2637 int64_t i64() const {
2638 return GetField<int64_t>(VT_I64, 0);
2639 }
2640 bool mutate_i64(int64_t _i64 = 0) {
2641 return SetField<int64_t>(VT_I64, _i64, 0);
2642 }
2643 uint64_t u64() const {
2644 return GetField<uint64_t>(VT_U64, 0);
2645 }
2646 bool mutate_u64(uint64_t _u64 = 0) {
2647 return SetField<uint64_t>(VT_U64, _u64, 0);
2648 }
2649 float f32() const {
2650 return GetField<float>(VT_F32, 0.0f);
2651 }
2652 bool mutate_f32(float _f32 = 0.0f) {
2653 return SetField<float>(VT_F32, _f32, 0.0f);
2654 }
2655 double f64() const {
2656 return GetField<double>(VT_F64, 0.0);
2657 }
2658 bool mutate_f64(double _f64 = 0.0) {
2659 return SetField<double>(VT_F64, _f64, 0.0);
2660 }
2661 const ::flatbuffers::Vector<int8_t> *v8() const {
2662 return GetPointer<const ::flatbuffers::Vector<int8_t> *>(VT_V8);
2663 }
2664 ::flatbuffers::Vector<int8_t> *mutable_v8() {
2665 return GetPointer<::flatbuffers::Vector<int8_t> *>(VT_V8);
2666 }
2667 const ::flatbuffers::Vector<double> *vf64() const {
2668 return GetPointer<const ::flatbuffers::Vector<double> *>(VT_VF64);
2669 }
2670 ::flatbuffers::Vector<double> *mutable_vf64() {
2671 return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
2672 }
2673 template<size_t Index>
2674 auto get_field() const {
2675 if constexpr (Index == 0) return i8();
2676 else if constexpr (Index == 1) return u8();
2677 else if constexpr (Index == 2) return i16();
2678 else if constexpr (Index == 3) return u16();
2679 else if constexpr (Index == 4) return i32();
2680 else if constexpr (Index == 5) return u32();
2681 else if constexpr (Index == 6) return i64();
2682 else if constexpr (Index == 7) return u64();
2683 else if constexpr (Index == 8) return f32();
2684 else if constexpr (Index == 9) return f64();
2685 else if constexpr (Index == 10) return v8();
2686 else if constexpr (Index == 11) return vf64();
2687 else static_assert(Index != Index, "Invalid Field Index");
2688 }
2689 bool Verify(::flatbuffers::Verifier &verifier) const {
2690 return VerifyTableStart(verifier) &&
2691 VerifyField<int8_t>(verifier, VT_I8, 1) &&
2692 VerifyField<uint8_t>(verifier, VT_U8, 1) &&
2693 VerifyField<int16_t>(verifier, VT_I16, 2) &&
2694 VerifyField<uint16_t>(verifier, VT_U16, 2) &&
2695 VerifyField<int32_t>(verifier, VT_I32, 4) &&
2696 VerifyField<uint32_t>(verifier, VT_U32, 4) &&
2697 VerifyField<int64_t>(verifier, VT_I64, 8) &&
2698 VerifyField<uint64_t>(verifier, VT_U64, 8) &&
2699 VerifyField<float>(verifier, VT_F32, 4) &&
2700 VerifyField<double>(verifier, VT_F64, 8) &&
2701 VerifyOffset(verifier, VT_V8) &&
2702 verifier.VerifyVector(v8()) &&
2703 VerifyOffset(verifier, VT_VF64) &&
2704 verifier.VerifyVector(vf64()) &&
2705 verifier.EndTable();
2706 }
2707 TypeAliasesT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
2708 void UnPackTo(TypeAliasesT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
2709 static ::flatbuffers::Offset<TypeAliases> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2710};
2711
2712struct TypeAliasesBuilder {
2713 typedef TypeAliases Table;
2714 ::flatbuffers::FlatBufferBuilder &fbb_;
2715 ::flatbuffers::uoffset_t start_;
2716 void add_i8(int8_t i8) {
2717 fbb_.AddElement<int8_t>(TypeAliases::VT_I8, i8, 0);
2718 }
2719 void add_u8(uint8_t u8) {
2720 fbb_.AddElement<uint8_t>(TypeAliases::VT_U8, u8, 0);
2721 }
2722 void add_i16(int16_t i16) {
2723 fbb_.AddElement<int16_t>(TypeAliases::VT_I16, i16, 0);
2724 }
2725 void add_u16(uint16_t u16) {
2726 fbb_.AddElement<uint16_t>(TypeAliases::VT_U16, u16, 0);
2727 }
2728 void add_i32(int32_t i32) {
2729 fbb_.AddElement<int32_t>(TypeAliases::VT_I32, i32, 0);
2730 }
2731 void add_u32(uint32_t u32) {
2732 fbb_.AddElement<uint32_t>(TypeAliases::VT_U32, u32, 0);
2733 }
2734 void add_i64(int64_t i64) {
2735 fbb_.AddElement<int64_t>(TypeAliases::VT_I64, i64, 0);
2736 }
2737 void add_u64(uint64_t u64) {
2738 fbb_.AddElement<uint64_t>(TypeAliases::VT_U64, u64, 0);
2739 }
2740 void add_f32(float f32) {
2741 fbb_.AddElement<float>(TypeAliases::VT_F32, f32, 0.0f);
2742 }
2743 void add_f64(double f64) {
2744 fbb_.AddElement<double>(TypeAliases::VT_F64, f64, 0.0);
2745 }
2746 void add_v8(::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> v8) {
2747 fbb_.AddOffset(TypeAliases::VT_V8, v8);
2748 }
2749 void add_vf64(::flatbuffers::Offset<::flatbuffers::Vector<double>> vf64) {
2750 fbb_.AddOffset(TypeAliases::VT_VF64, vf64);
2751 }
2752 explicit TypeAliasesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2753 : fbb_(_fbb) {
2754 start_ = fbb_.StartTable();
2755 }
2756 ::flatbuffers::Offset<TypeAliases> Finish() {
2757 const auto end = fbb_.EndTable(start_);
2758 auto o = ::flatbuffers::Offset<TypeAliases>(end);
2759 return o;
2760 }
2761};
2762
2763inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(
2764 ::flatbuffers::FlatBufferBuilder &_fbb,
2765 int8_t i8 = 0,
2766 uint8_t u8 = 0,
2767 int16_t i16 = 0,
2768 uint16_t u16 = 0,
2769 int32_t i32 = 0,
2770 uint32_t u32 = 0,
2771 int64_t i64 = 0,
2772 uint64_t u64 = 0,
2773 float f32 = 0.0f,
2774 double f64 = 0.0,
2775 ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> v8 = 0,
2776 ::flatbuffers::Offset<::flatbuffers::Vector<double>> vf64 = 0) {
2777 TypeAliasesBuilder builder_(_fbb);
2778 builder_.add_f64(f64);
2779 builder_.add_u64(u64);
2780 builder_.add_i64(i64);
2781 builder_.add_vf64(vf64);
2782 builder_.add_v8(v8);
2783 builder_.add_f32(f32);
2784 builder_.add_u32(u32);
2785 builder_.add_i32(i32);
2786 builder_.add_u16(u16);
2787 builder_.add_i16(i16);
2788 builder_.add_u8(u8);
2789 builder_.add_i8(i8);
2790 return builder_.Finish();
2791}
2792
2793struct TypeAliases::Traits {
2794 using type = TypeAliases;
2795 static auto constexpr Create = CreateTypeAliases;
2796 static constexpr auto name = "TypeAliases";
2797 static constexpr auto fully_qualified_name = "MyGame.Example.TypeAliases";
2798 static constexpr size_t fields_number = 12;
2799 static constexpr std::array<const char *, fields_number> field_names = {
2800 "i8",
2801 "u8",
2802 "i16",
2803 "u16",
2804 "i32",
2805 "u32",
2806 "i64",
2807 "u64",
2808 "f32",
2809 "f64",
2810 "v8",
2811 "vf64"
2812 };
2813 template<size_t Index>
2814 using FieldType = decltype(std::declval<type>().get_field<Index>());
2815};
2816
2817inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliasesDirect(
2818 ::flatbuffers::FlatBufferBuilder &_fbb,
2819 int8_t i8 = 0,
2820 uint8_t u8 = 0,
2821 int16_t i16 = 0,
2822 uint16_t u16 = 0,
2823 int32_t i32 = 0,
2824 uint32_t u32 = 0,
2825 int64_t i64 = 0,
2826 uint64_t u64 = 0,
2827 float f32 = 0.0f,
2828 double f64 = 0.0,
2829 const std::vector<int8_t> *v8 = nullptr,
2830 const std::vector<double> *vf64 = nullptr) {
2831 auto v8__ = v8 ? _fbb.CreateVector<int8_t>(*v8) : 0;
2832 auto vf64__ = vf64 ? _fbb.CreateVector<double>(*vf64) : 0;
2833 return MyGame::Example::CreateTypeAliases(
2834 _fbb,
2835 i8,
2836 u8,
2837 i16,
2838 u16,
2839 i32,
2840 u32,
2841 i64,
2842 u64,
2843 f32,
2844 f64,
2845 v8__,
2846 vf64__);
2847}
2848
2849::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
2850
2851} // namespace Example
2852
2853inline InParentNamespaceT *InParentNamespace::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2854 auto _o = std::make_unique<InParentNamespaceT>();
2855 UnPackTo(_o.get(), _resolver);
2856 return _o.release();
2857}
2858
2859inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2860 (void)_o;
2861 (void)_resolver;
2862}
2863
2864inline ::flatbuffers::Offset<InParentNamespace> InParentNamespace::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2865 return CreateInParentNamespace(_fbb, _o, _rehasher);
2866}
2867
2868inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2869 (void)_rehasher;
2870 (void)_o;
2871 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2872 return MyGame::CreateInParentNamespace(
2873 _fbb);
2874}
2875
2876namespace Example2 {
2877
2878inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2879 auto _o = std::make_unique<MonsterT>();
2880 UnPackTo(_o.get(), _resolver);
2881 return _o.release();
2882}
2883
2884inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2885 (void)_o;
2886 (void)_resolver;
2887}
2888
2889inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2890 return CreateMonster(_fbb, _o, _rehasher);
2891}
2892
2893inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2894 (void)_rehasher;
2895 (void)_o;
2896 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2897 return MyGame::Example2::CreateMonster(
2898 _fbb);
2899}
2900
2901} // namespace Example2
2902
2903namespace Example {
2904
2905inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2906 auto _o = std::make_unique<TestSimpleTableWithEnumT>();
2907 UnPackTo(_o.get(), _resolver);
2908 return _o.release();
2909}
2910
2911inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2912 (void)_o;
2913 (void)_resolver;
2914 { auto _e = color(); _o->color = _e; }
2915}
2916
2917inline ::flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2918 return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher);
2919}
2920
2921inline ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2922 (void)_rehasher;
2923 (void)_o;
2924 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2925 auto _color = _o->color;
2926 return MyGame::Example::CreateTestSimpleTableWithEnum(
2927 _fbb,
2928 _color);
2929}
2930
2931inline StatT *Stat::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2932 auto _o = std::make_unique<StatT>();
2933 UnPackTo(_o.get(), _resolver);
2934 return _o.release();
2935}
2936
2937inline void Stat::UnPackTo(StatT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2938 (void)_o;
2939 (void)_resolver;
2940 { auto _e = id(); if (_e) _o->id = _e->str(); }
2941 { auto _e = val(); _o->val = _e; }
2942 { auto _e = count(); _o->count = _e; }
2943}
2944
2945inline ::flatbuffers::Offset<Stat> Stat::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2946 return CreateStat(_fbb, _o, _rehasher);
2947}
2948
2949inline ::flatbuffers::Offset<Stat> CreateStat(::flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2950 (void)_rehasher;
2951 (void)_o;
2952 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2953 auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id);
2954 auto _val = _o->val;
2955 auto _count = _o->count;
2956 return MyGame::Example::CreateStat(
2957 _fbb,
2958 _id,
2959 _val,
2960 _count);
2961}
2962
2963inline ReferrableT *Referrable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
2964 auto _o = std::make_unique<ReferrableT>();
2965 UnPackTo(_o.get(), _resolver);
2966 return _o.release();
2967}
2968
2969inline void Referrable::UnPackTo(ReferrableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
2970 (void)_o;
2971 (void)_resolver;
2972 { auto _e = id(); _o->id = _e; }
2973}
2974
2975inline ::flatbuffers::Offset<Referrable> Referrable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2976 return CreateReferrable(_fbb, _o, _rehasher);
2977}
2978
2979inline ::flatbuffers::Offset<Referrable> CreateReferrable(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
2980 (void)_rehasher;
2981 (void)_o;
2982 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2983 auto _id = _o->id;
2984 return MyGame::Example::CreateReferrable(
2985 _fbb,
2986 _id);
2987}
2988
2989inline MonsterT::MonsterT(const MonsterT &o)
2990 : pos((o.pos) ? new MyGame::Example::Vec3(*o.pos) : nullptr),
2991 mana(o.mana),
2992 hp(o.hp),
2993 name(o.name),
2994 inventory(o.inventory),
2995 color(o.color),
2996 test(o.test),
2997 test4(o.test4),
2998 testarrayofstring(o.testarrayofstring),
2999 enemy((o.enemy) ? new MyGame::Example::MonsterT(*o.enemy) : nullptr),
3000 testnestedflatbuffer(o.testnestedflatbuffer),
3001 testempty((o.testempty) ? new MyGame::Example::StatT(*o.testempty) : nullptr),
3002 testbool(o.testbool),
3003 testhashs32_fnv1(o.testhashs32_fnv1),
3004 testhashu32_fnv1(o.testhashu32_fnv1),
3005 testhashs64_fnv1(o.testhashs64_fnv1),
3006 testhashu64_fnv1(o.testhashu64_fnv1),
3007 testhashs32_fnv1a(o.testhashs32_fnv1a),
3008 testhashu32_fnv1a(o.testhashu32_fnv1a),
3009 testhashs64_fnv1a(o.testhashs64_fnv1a),
3010 testhashu64_fnv1a(o.testhashu64_fnv1a),
3011 testarrayofbools(o.testarrayofbools),
3012 testf(o.testf),
3013 testf2(o.testf2),
3014 testf3(o.testf3),
3015 testarrayofstring2(o.testarrayofstring2),
3016 testarrayofsortedstruct(o.testarrayofsortedstruct),
3017 flex(o.flex),
3018 test5(o.test5),
3019 vector_of_longs(o.vector_of_longs),
3020 vector_of_doubles(o.vector_of_doubles),
3021 parent_namespace_test((o.parent_namespace_test) ? new MyGame::InParentNamespaceT(*o.parent_namespace_test) : nullptr),
3022 single_weak_reference(o.single_weak_reference),
3023 vector_of_weak_references(o.vector_of_weak_references),
3024 co_owning_reference(o.co_owning_reference),
3025 non_owning_reference(o.non_owning_reference),
3026 vector_of_non_owning_references(o.vector_of_non_owning_references),
3027 any_unique(o.any_unique),
3028 any_ambiguous(o.any_ambiguous),
3029 vector_of_enums(o.vector_of_enums),
3030 signed_enum(o.signed_enum),
3031 testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
3032 native_inline(o.native_inline),
3033 long_enum_non_enum_default(o.long_enum_non_enum_default),
3034 long_enum_normal_default(o.long_enum_normal_default),
3035 nan_default(o.nan_default),
3036 inf_default(o.inf_default),
3037 positive_inf_default(o.positive_inf_default),
3038 infinity_default(o.infinity_default),
3039 positive_infinity_default(o.positive_infinity_default),
3040 negative_inf_default(o.negative_inf_default),
3041 negative_infinity_default(o.negative_infinity_default),
3042 double_inf_default(o.double_inf_default) {
3043 testarrayoftables.reserve(o.testarrayoftables.size());
3044 for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
3045 vector_of_referrables.reserve(o.vector_of_referrables.size());
3046 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); }
3047 vector_of_strong_referrables.reserve(o.vector_of_strong_referrables.size());
3048 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); }
3049 vector_of_co_owning_references.reserve(o.vector_of_co_owning_references.size());
3050 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); }
3051 scalar_key_sorted_tables.reserve(o.scalar_key_sorted_tables.size());
3052 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); }
3053}
3054
3055inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
3056 std::swap(pos, o.pos);
3057 std::swap(mana, o.mana);
3058 std::swap(hp, o.hp);
3059 std::swap(name, o.name);
3060 std::swap(inventory, o.inventory);
3061 std::swap(color, o.color);
3062 std::swap(test, o.test);
3063 std::swap(test4, o.test4);
3064 std::swap(testarrayofstring, o.testarrayofstring);
3065 std::swap(testarrayoftables, o.testarrayoftables);
3066 std::swap(enemy, o.enemy);
3067 std::swap(testnestedflatbuffer, o.testnestedflatbuffer);
3068 std::swap(testempty, o.testempty);
3069 std::swap(testbool, o.testbool);
3070 std::swap(testhashs32_fnv1, o.testhashs32_fnv1);
3071 std::swap(testhashu32_fnv1, o.testhashu32_fnv1);
3072 std::swap(testhashs64_fnv1, o.testhashs64_fnv1);
3073 std::swap(testhashu64_fnv1, o.testhashu64_fnv1);
3074 std::swap(testhashs32_fnv1a, o.testhashs32_fnv1a);
3075 std::swap(testhashu32_fnv1a, o.testhashu32_fnv1a);
3076 std::swap(testhashs64_fnv1a, o.testhashs64_fnv1a);
3077 std::swap(testhashu64_fnv1a, o.testhashu64_fnv1a);
3078 std::swap(testarrayofbools, o.testarrayofbools);
3079 std::swap(testf, o.testf);
3080 std::swap(testf2, o.testf2);
3081 std::swap(testf3, o.testf3);
3082 std::swap(testarrayofstring2, o.testarrayofstring2);
3083 std::swap(testarrayofsortedstruct, o.testarrayofsortedstruct);
3084 std::swap(flex, o.flex);
3085 std::swap(test5, o.test5);
3086 std::swap(vector_of_longs, o.vector_of_longs);
3087 std::swap(vector_of_doubles, o.vector_of_doubles);
3088 std::swap(parent_namespace_test, o.parent_namespace_test);
3089 std::swap(vector_of_referrables, o.vector_of_referrables);
3090 std::swap(single_weak_reference, o.single_weak_reference);
3091 std::swap(vector_of_weak_references, o.vector_of_weak_references);
3092 std::swap(vector_of_strong_referrables, o.vector_of_strong_referrables);
3093 std::swap(co_owning_reference, o.co_owning_reference);
3094 std::swap(vector_of_co_owning_references, o.vector_of_co_owning_references);
3095 std::swap(non_owning_reference, o.non_owning_reference);
3096 std::swap(vector_of_non_owning_references, o.vector_of_non_owning_references);
3097 std::swap(any_unique, o.any_unique);
3098 std::swap(any_ambiguous, o.any_ambiguous);
3099 std::swap(vector_of_enums, o.vector_of_enums);
3100 std::swap(signed_enum, o.signed_enum);
3101 std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer);
3102 std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables);
3103 std::swap(native_inline, o.native_inline);
3104 std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
3105 std::swap(long_enum_normal_default, o.long_enum_normal_default);
3106 std::swap(nan_default, o.nan_default);
3107 std::swap(inf_default, o.inf_default);
3108 std::swap(positive_inf_default, o.positive_inf_default);
3109 std::swap(infinity_default, o.infinity_default);
3110 std::swap(positive_infinity_default, o.positive_infinity_default);
3111 std::swap(negative_inf_default, o.negative_inf_default);
3112 std::swap(negative_infinity_default, o.negative_infinity_default);
3113 std::swap(double_inf_default, o.double_inf_default);
3114 return *this;
3115}
3116
3117inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
3118 auto _o = std::make_unique<MonsterT>();
3119 UnPackTo(_o.get(), _resolver);
3120 return _o.release();
3121}
3122
3123inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
3124 (void)_o;
3125 (void)_resolver;
3126 { auto _e = pos(); if (_e) _o->pos = std::unique_ptr<MyGame::Example::Vec3>(new MyGame::Example::Vec3(*_e)); }
3127 { auto _e = mana(); _o->mana = _e; }
3128 { auto _e = hp(); _o->hp = _e; }
3129 { auto _e = name(); if (_e) _o->name = _e->str(); }
3130 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } }
3131 { auto _e = color(); _o->color = _e; }
3132 { auto _e = test_type(); _o->test.type = _e; }
3133 { auto _e = test(); if (_e) _o->test.value = MyGame::Example::AnyUnion::UnPack(_e, test_type(), _resolver); }
3134 { 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); } }
3135 { 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); } }
3136 { 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); } }
3137 { 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(); } }
3138 { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testnestedflatbuffer.begin()); } }
3139 { 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(); } }
3140 { auto _e = testbool(); _o->testbool = _e; }
3141 { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }
3142 { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; }
3143 { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; }
3144 { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; }
3145 { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; }
3146 { 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; }
3147 { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; }
3148 { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; }
3149 { 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); } }
3150 { auto _e = testf(); _o->testf = _e; }
3151 { auto _e = testf2(); _o->testf2 = _e; }
3152 { auto _e = testf3(); _o->testf3 = _e; }
3153 { 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); } }
3154 { 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); } }
3155 { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->flex.begin()); } }
3156 { 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); } }
3157 { 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); } }
3158 { 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); } }
3159 { 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(); } }
3160 { 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); } }
3161 { 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; }
3162 { 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); } }
3163 { 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); } }
3164 { 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; }
3165 { 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); } }
3166 { 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; }
3167 { 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); } }
3168 { auto _e = any_unique_type(); _o->any_unique.type = _e; }
3169 { auto _e = any_unique(); if (_e) _o->any_unique.value = MyGame::Example::AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); }
3170 { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; }
3171 { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
3172 { 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); } }
3173 { auto _e = signed_enum(); _o->signed_enum = _e; }
3174 { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
3175 { 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); } }
3176 { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
3177 { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
3178 { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
3179 { auto _e = nan_default(); _o->nan_default = _e; }
3180 { auto _e = inf_default(); _o->inf_default = _e; }
3181 { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
3182 { auto _e = infinity_default(); _o->infinity_default = _e; }
3183 { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
3184 { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
3185 { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
3186 { auto _e = double_inf_default(); _o->double_inf_default = _e; }
3187}
3188
3189inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3190 return CreateMonster(_fbb, _o, _rehasher);
3191}
3192
3193inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3194 (void)_rehasher;
3195 (void)_o;
3196 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3197 auto _pos = _o->pos ? _o->pos.get() : nullptr;
3198 auto _mana = _o->mana;
3199 auto _hp = _o->hp;
3200 auto _name = _fbb.CreateString(_o->name);
3201 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
3202 auto _color = _o->color;
3203 auto _test_type = _o->test.type;
3204 auto _test = _o->test.Pack(_fbb);
3205 auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
3206 auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
3207 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;
3208 auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
3209 auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
3210 auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
3211 auto _testbool = _o->testbool;
3212 auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
3213 auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
3214 auto _testhashs64_fnv1 = _o->testhashs64_fnv1;
3215 auto _testhashu64_fnv1 = _o->testhashu64_fnv1;
3216 auto _testhashs32_fnv1a = _o->testhashs32_fnv1a;
3217 auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0;
3218 auto _testhashs64_fnv1a = _o->testhashs64_fnv1a;
3219 auto _testhashu64_fnv1a = _o->testhashu64_fnv1a;
3220 auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0;
3221 auto _testf = _o->testf;
3222 auto _testf2 = _o->testf2;
3223 auto _testf3 = _o->testf3;
3224 auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0;
3225 auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0;
3226 auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0;
3227 auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0;
3228 auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
3229 auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
3230 auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
3231 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;
3232 auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
3233 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;
3234 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;
3235 auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0;
3236 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;
3237 auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0;
3238 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;
3239 auto _any_unique_type = _o->any_unique.type;
3240 auto _any_unique = _o->any_unique.Pack(_fbb);
3241 auto _any_ambiguous_type = _o->any_ambiguous.type;
3242 auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
3243 auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
3244 auto _signed_enum = _o->signed_enum;
3245 auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
3246 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;
3247 auto _native_inline = &_o->native_inline;
3248 auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
3249 auto _long_enum_normal_default = _o->long_enum_normal_default;
3250 auto _nan_default = _o->nan_default;
3251 auto _inf_default = _o->inf_default;
3252 auto _positive_inf_default = _o->positive_inf_default;
3253 auto _infinity_default = _o->infinity_default;
3254 auto _positive_infinity_default = _o->positive_infinity_default;
3255 auto _negative_inf_default = _o->negative_inf_default;
3256 auto _negative_infinity_default = _o->negative_infinity_default;
3257 auto _double_inf_default = _o->double_inf_default;
3258 return MyGame::Example::CreateMonster(
3259 _fbb,
3260 _pos,
3261 _mana,
3262 _hp,
3263 _name,
3264 _inventory,
3265 _color,
3266 _test_type,
3267 _test,
3268 _test4,
3269 _testarrayofstring,
3270 _testarrayoftables,
3271 _enemy,
3272 _testnestedflatbuffer,
3273 _testempty,
3274 _testbool,
3275 _testhashs32_fnv1,
3276 _testhashu32_fnv1,
3277 _testhashs64_fnv1,
3278 _testhashu64_fnv1,
3279 _testhashs32_fnv1a,
3280 _testhashu32_fnv1a,
3281 _testhashs64_fnv1a,
3282 _testhashu64_fnv1a,
3283 _testarrayofbools,
3284 _testf,
3285 _testf2,
3286 _testf3,
3287 _testarrayofstring2,
3288 _testarrayofsortedstruct,
3289 _flex,
3290 _test5,
3291 _vector_of_longs,
3292 _vector_of_doubles,
3293 _parent_namespace_test,
3294 _vector_of_referrables,
3295 _single_weak_reference,
3296 _vector_of_weak_references,
3297 _vector_of_strong_referrables,
3298 _co_owning_reference,
3299 _vector_of_co_owning_references,
3300 _non_owning_reference,
3301 _vector_of_non_owning_references,
3302 _any_unique_type,
3303 _any_unique,
3304 _any_ambiguous_type,
3305 _any_ambiguous,
3306 _vector_of_enums,
3307 _signed_enum,
3308 _testrequirednestedflatbuffer,
3309 _scalar_key_sorted_tables,
3310 _native_inline,
3311 _long_enum_non_enum_default,
3312 _long_enum_normal_default,
3313 _nan_default,
3314 _inf_default,
3315 _positive_inf_default,
3316 _infinity_default,
3317 _positive_infinity_default,
3318 _negative_inf_default,
3319 _negative_infinity_default,
3320 _double_inf_default);
3321}
3322
3323inline TypeAliasesT *TypeAliases::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
3324 auto _o = std::make_unique<TypeAliasesT>();
3325 UnPackTo(_o.get(), _resolver);
3326 return _o.release();
3327}
3328
3329inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
3330 (void)_o;
3331 (void)_resolver;
3332 { auto _e = i8(); _o->i8 = _e; }
3333 { auto _e = u8(); _o->u8 = _e; }
3334 { auto _e = i16(); _o->i16 = _e; }
3335 { auto _e = u16(); _o->u16 = _e; }
3336 { auto _e = i32(); _o->i32 = _e; }
3337 { auto _e = u32(); _o->u32 = _e; }
3338 { auto _e = i64(); _o->i64 = _e; }
3339 { auto _e = u64(); _o->u64 = _e; }
3340 { auto _e = f32(); _o->f32 = _e; }
3341 { auto _e = f64(); _o->f64 = _e; }
3342 { auto _e = v8(); if (_e) { _o->v8.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->v8.begin()); } }
3343 { 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); } }
3344}
3345
3346inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3347 return CreateTypeAliases(_fbb, _o, _rehasher);
3348}
3349
3350inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
3351 (void)_rehasher;
3352 (void)_o;
3353 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3354 auto _i8 = _o->i8;
3355 auto _u8 = _o->u8;
3356 auto _i16 = _o->i16;
3357 auto _u16 = _o->u16;
3358 auto _i32 = _o->i32;
3359 auto _u32 = _o->u32;
3360 auto _i64 = _o->i64;
3361 auto _u64 = _o->u64;
3362 auto _f32 = _o->f32;
3363 auto _f64 = _o->f64;
3364 auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0;
3365 auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0;
3366 return MyGame::Example::CreateTypeAliases(
3367 _fbb,
3368 _i8,
3369 _u8,
3370 _i16,
3371 _u16,
3372 _i32,
3373 _u32,
3374 _i64,
3375 _u64,
3376 _f32,
3377 _f64,
3378 _v8,
3379 _vf64);
3380}
3381
3382inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
3383 switch (type) {
3384 case Any::NONE: {
3385 return true;
3386 }
3387 case Any::Monster: {
3388 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3389 return verifier.VerifyTable(ptr);
3390 }
3391 case Any::TestSimpleTableWithEnum: {
3392 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3393 return verifier.VerifyTable(ptr);
3394 }
3395 case Any::MyGame_Example2_Monster: {
3396 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3397 return verifier.VerifyTable(ptr);
3398 }
3399 default: return true;
3400 }
3401}
3402
3403inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
3404 if (!values || !types) return !values && !types;
3405 if (values->size() != types->size()) return false;
3406 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3407 if (!VerifyAny(
3408 verifier, values->Get(i), types->GetEnum<Any>(i))) {
3409 return false;
3410 }
3411 }
3412 return true;
3413}
3414
3415inline void *AnyUnion::UnPack(const void *obj, Any type, const ::flatbuffers::resolver_function_t *resolver) {
3416 (void)resolver;
3417 switch (type) {
3418 case Any::Monster: {
3419 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3420 return ptr->UnPack(resolver);
3421 }
3422 case Any::TestSimpleTableWithEnum: {
3423 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3424 return ptr->UnPack(resolver);
3425 }
3426 case Any::MyGame_Example2_Monster: {
3427 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3428 return ptr->UnPack(resolver);
3429 }
3430 default: return nullptr;
3431 }
3432}
3433
3434inline ::flatbuffers::Offset<void> AnyUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3435 (void)_rehasher;
3436 switch (type) {
3437 case Any::Monster: {
3438 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3439 return CreateMonster(_fbb, ptr, _rehasher).Union();
3440 }
3441 case Any::TestSimpleTableWithEnum: {
3442 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value);
3443 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
3444 }
3445 case Any::MyGame_Example2_Monster: {
3446 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
3447 return CreateMonster(_fbb, ptr, _rehasher).Union();
3448 }
3449 default: return 0;
3450 }
3451}
3452
3453inline AnyUnion::AnyUnion(const AnyUnion &u) : type(u.type), value(nullptr) {
3454 switch (type) {
3455 case Any::Monster: {
3456 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3457 break;
3458 }
3459 case Any::TestSimpleTableWithEnum: {
3460 value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(u.value));
3461 break;
3462 }
3463 case Any::MyGame_Example2_Monster: {
3464 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
3465 break;
3466 }
3467 default:
3468 break;
3469 }
3470}
3471
3472inline void AnyUnion::Reset() {
3473 switch (type) {
3474 case Any::Monster: {
3475 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3476 delete ptr;
3477 break;
3478 }
3479 case Any::TestSimpleTableWithEnum: {
3480 auto ptr = reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value);
3481 delete ptr;
3482 break;
3483 }
3484 case Any::MyGame_Example2_Monster: {
3485 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
3486 delete ptr;
3487 break;
3488 }
3489 default: break;
3490 }
3491 value = nullptr;
3492 type = Any::NONE;
3493}
3494
3495inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
3496 switch (type) {
3497 case AnyUniqueAliases::NONE: {
3498 return true;
3499 }
3500 case AnyUniqueAliases::M: {
3501 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3502 return verifier.VerifyTable(ptr);
3503 }
3504 case AnyUniqueAliases::TS: {
3505 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3506 return verifier.VerifyTable(ptr);
3507 }
3508 case AnyUniqueAliases::M2: {
3509 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3510 return verifier.VerifyTable(ptr);
3511 }
3512 default: return true;
3513 }
3514}
3515
3516inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
3517 if (!values || !types) return !values && !types;
3518 if (values->size() != types->size()) return false;
3519 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3520 if (!VerifyAnyUniqueAliases(
3521 verifier, values->Get(i), types->GetEnum<AnyUniqueAliases>(i))) {
3522 return false;
3523 }
3524 }
3525 return true;
3526}
3527
3528inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const ::flatbuffers::resolver_function_t *resolver) {
3529 (void)resolver;
3530 switch (type) {
3531 case AnyUniqueAliases::M: {
3532 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3533 return ptr->UnPack(resolver);
3534 }
3535 case AnyUniqueAliases::TS: {
3536 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnum *>(obj);
3537 return ptr->UnPack(resolver);
3538 }
3539 case AnyUniqueAliases::M2: {
3540 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
3541 return ptr->UnPack(resolver);
3542 }
3543 default: return nullptr;
3544 }
3545}
3546
3547inline ::flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3548 (void)_rehasher;
3549 switch (type) {
3550 case AnyUniqueAliases::M: {
3551 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3552 return CreateMonster(_fbb, ptr, _rehasher).Union();
3553 }
3554 case AnyUniqueAliases::TS: {
3555 auto ptr = reinterpret_cast<const MyGame::Example::TestSimpleTableWithEnumT *>(value);
3556 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
3557 }
3558 case AnyUniqueAliases::M2: {
3559 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
3560 return CreateMonster(_fbb, ptr, _rehasher).Union();
3561 }
3562 default: return 0;
3563 }
3564}
3565
3566inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : type(u.type), value(nullptr) {
3567 switch (type) {
3568 case AnyUniqueAliases::M: {
3569 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3570 break;
3571 }
3572 case AnyUniqueAliases::TS: {
3573 value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(u.value));
3574 break;
3575 }
3576 case AnyUniqueAliases::M2: {
3577 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
3578 break;
3579 }
3580 default:
3581 break;
3582 }
3583}
3584
3585inline void AnyUniqueAliasesUnion::Reset() {
3586 switch (type) {
3587 case AnyUniqueAliases::M: {
3588 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3589 delete ptr;
3590 break;
3591 }
3592 case AnyUniqueAliases::TS: {
3593 auto ptr = reinterpret_cast<MyGame::Example::TestSimpleTableWithEnumT *>(value);
3594 delete ptr;
3595 break;
3596 }
3597 case AnyUniqueAliases::M2: {
3598 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
3599 delete ptr;
3600 break;
3601 }
3602 default: break;
3603 }
3604 value = nullptr;
3605 type = AnyUniqueAliases::NONE;
3606}
3607
3608inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
3609 switch (type) {
3610 case AnyAmbiguousAliases::NONE: {
3611 return true;
3612 }
3613 case AnyAmbiguousAliases::M1: {
3614 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3615 return verifier.VerifyTable(ptr);
3616 }
3617 case AnyAmbiguousAliases::M2: {
3618 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3619 return verifier.VerifyTable(ptr);
3620 }
3621 case AnyAmbiguousAliases::M3: {
3622 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3623 return verifier.VerifyTable(ptr);
3624 }
3625 default: return true;
3626 }
3627}
3628
3629inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
3630 if (!values || !types) return !values && !types;
3631 if (values->size() != types->size()) return false;
3632 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3633 if (!VerifyAnyAmbiguousAliases(
3634 verifier, values->Get(i), types->GetEnum<AnyAmbiguousAliases>(i))) {
3635 return false;
3636 }
3637 }
3638 return true;
3639}
3640
3641inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const ::flatbuffers::resolver_function_t *resolver) {
3642 (void)resolver;
3643 switch (type) {
3644 case AnyAmbiguousAliases::M1: {
3645 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3646 return ptr->UnPack(resolver);
3647 }
3648 case AnyAmbiguousAliases::M2: {
3649 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3650 return ptr->UnPack(resolver);
3651 }
3652 case AnyAmbiguousAliases::M3: {
3653 auto ptr = reinterpret_cast<const MyGame::Example::Monster *>(obj);
3654 return ptr->UnPack(resolver);
3655 }
3656 default: return nullptr;
3657 }
3658}
3659
3660inline ::flatbuffers::Offset<void> AnyAmbiguousAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
3661 (void)_rehasher;
3662 switch (type) {
3663 case AnyAmbiguousAliases::M1: {
3664 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3665 return CreateMonster(_fbb, ptr, _rehasher).Union();
3666 }
3667 case AnyAmbiguousAliases::M2: {
3668 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3669 return CreateMonster(_fbb, ptr, _rehasher).Union();
3670 }
3671 case AnyAmbiguousAliases::M3: {
3672 auto ptr = reinterpret_cast<const MyGame::Example::MonsterT *>(value);
3673 return CreateMonster(_fbb, ptr, _rehasher).Union();
3674 }
3675 default: return 0;
3676 }
3677}
3678
3679inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : type(u.type), value(nullptr) {
3680 switch (type) {
3681 case AnyAmbiguousAliases::M1: {
3682 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3683 break;
3684 }
3685 case AnyAmbiguousAliases::M2: {
3686 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3687 break;
3688 }
3689 case AnyAmbiguousAliases::M3: {
3690 value = new MyGame::Example::MonsterT(*reinterpret_cast<MyGame::Example::MonsterT *>(u.value));
3691 break;
3692 }
3693 default:
3694 break;
3695 }
3696}
3697
3698inline void AnyAmbiguousAliasesUnion::Reset() {
3699 switch (type) {
3700 case AnyAmbiguousAliases::M1: {
3701 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3702 delete ptr;
3703 break;
3704 }
3705 case AnyAmbiguousAliases::M2: {
3706 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3707 delete ptr;
3708 break;
3709 }
3710 case AnyAmbiguousAliases::M3: {
3711 auto ptr = reinterpret_cast<MyGame::Example::MonsterT *>(value);
3712 delete ptr;
3713 break;
3714 }
3715 default: break;
3716 }
3717 value = nullptr;
3718 type = AnyAmbiguousAliases::NONE;
3719}
3720
3721inline const ::flatbuffers::TypeTable *ColorTypeTable() {
3722 static const ::flatbuffers::TypeCode type_codes[] = {
3723 { ::flatbuffers::ET_UCHAR, 0, 0 },
3724 { ::flatbuffers::ET_UCHAR, 0, 0 },
3725 { ::flatbuffers::ET_UCHAR, 0, 0 }
3726 };
3727 static const ::flatbuffers::TypeFunction type_refs[] = {
3728 MyGame::Example::ColorTypeTable
3729 };
3730 static const int64_t values[] = { 1, 2, 8 };
3731 static const char * const names[] = {
3732 "Red",
3733 "Green",
3734 "Blue"
3735 };
3736 static const ::flatbuffers::TypeTable tt = {
3737 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names
3738 };
3739 return &tt;
3740}
3741
3742inline const ::flatbuffers::TypeTable *RaceTypeTable() {
3743 static const ::flatbuffers::TypeCode type_codes[] = {
3744 { ::flatbuffers::ET_CHAR, 0, 0 },
3745 { ::flatbuffers::ET_CHAR, 0, 0 },
3746 { ::flatbuffers::ET_CHAR, 0, 0 },
3747 { ::flatbuffers::ET_CHAR, 0, 0 }
3748 };
3749 static const ::flatbuffers::TypeFunction type_refs[] = {
3750 MyGame::Example::RaceTypeTable
3751 };
3752 static const int64_t values[] = { -1, 0, 1, 2 };
3753 static const char * const names[] = {
3754 "None",
3755 "Human",
3756 "Dwarf",
3757 "Elf"
3758 };
3759 static const ::flatbuffers::TypeTable tt = {
3760 ::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names
3761 };
3762 return &tt;
3763}
3764
3765inline const ::flatbuffers::TypeTable *LongEnumTypeTable() {
3766 static const ::flatbuffers::TypeCode type_codes[] = {
3767 { ::flatbuffers::ET_ULONG, 0, 0 },
3768 { ::flatbuffers::ET_ULONG, 0, 0 },
3769 { ::flatbuffers::ET_ULONG, 0, 0 }
3770 };
3771 static const ::flatbuffers::TypeFunction type_refs[] = {
3772 MyGame::Example::LongEnumTypeTable
3773 };
3774 static const int64_t values[] = { 2ULL, 4ULL, 1099511627776ULL };
3775 static const char * const names[] = {
3776 "LongOne",
3777 "LongTwo",
3778 "LongBig"
3779 };
3780 static const ::flatbuffers::TypeTable tt = {
3781 ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names
3782 };
3783 return &tt;
3784}
3785
3786inline const ::flatbuffers::TypeTable *AnyTypeTable() {
3787 static const ::flatbuffers::TypeCode type_codes[] = {
3788 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3789 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3790 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3791 { ::flatbuffers::ET_SEQUENCE, 0, 2 }
3792 };
3793 static const ::flatbuffers::TypeFunction type_refs[] = {
3794 MyGame::Example::MonsterTypeTable,
3795 MyGame::Example::TestSimpleTableWithEnumTypeTable,
3796 MyGame::Example2::MonsterTypeTable
3797 };
3798 static const char * const names[] = {
3799 "NONE",
3800 "Monster",
3801 "TestSimpleTableWithEnum",
3802 "MyGame_Example2_Monster"
3803 };
3804 static const ::flatbuffers::TypeTable tt = {
3805 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3806 };
3807 return &tt;
3808}
3809
3810inline const ::flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() {
3811 static const ::flatbuffers::TypeCode type_codes[] = {
3812 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3813 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3814 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3815 { ::flatbuffers::ET_SEQUENCE, 0, 2 }
3816 };
3817 static const ::flatbuffers::TypeFunction type_refs[] = {
3818 MyGame::Example::MonsterTypeTable,
3819 MyGame::Example::TestSimpleTableWithEnumTypeTable,
3820 MyGame::Example2::MonsterTypeTable
3821 };
3822 static const char * const names[] = {
3823 "NONE",
3824 "M",
3825 "TS",
3826 "M2"
3827 };
3828 static const ::flatbuffers::TypeTable tt = {
3829 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3830 };
3831 return &tt;
3832}
3833
3834inline const ::flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() {
3835 static const ::flatbuffers::TypeCode type_codes[] = {
3836 { ::flatbuffers::ET_SEQUENCE, 0, -1 },
3837 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3838 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3839 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3840 };
3841 static const ::flatbuffers::TypeFunction type_refs[] = {
3842 MyGame::Example::MonsterTypeTable
3843 };
3844 static const char * const names[] = {
3845 "NONE",
3846 "M1",
3847 "M2",
3848 "M3"
3849 };
3850 static const ::flatbuffers::TypeTable tt = {
3851 ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
3852 };
3853 return &tt;
3854}
3855
3856} // namespace Example
3857
3858inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable() {
3859 static const ::flatbuffers::TypeTable tt = {
3860 ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
3861 };
3862 return &tt;
3863}
3864
3865namespace Example2 {
3866
3867inline const ::flatbuffers::TypeTable *MonsterTypeTable() {
3868 static const ::flatbuffers::TypeTable tt = {
3869 ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
3870 };
3871 return &tt;
3872}
3873
3874} // namespace Example2
3875
3876namespace Example {
3877
3878inline const ::flatbuffers::TypeTable *TestTypeTable() {
3879 static const ::flatbuffers::TypeCode type_codes[] = {
3880 { ::flatbuffers::ET_SHORT, 0, -1 },
3881 { ::flatbuffers::ET_CHAR, 0, -1 }
3882 };
3883 static const int64_t values[] = { 0, 2, 4 };
3884 static const char * const names[] = {
3885 "a",
3886 "b"
3887 };
3888 static const ::flatbuffers::TypeTable tt = {
3889 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
3890 };
3891 return &tt;
3892}
3893
3894inline const ::flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() {
3895 static const ::flatbuffers::TypeCode type_codes[] = {
3896 { ::flatbuffers::ET_UCHAR, 0, 0 }
3897 };
3898 static const ::flatbuffers::TypeFunction type_refs[] = {
3899 MyGame::Example::ColorTypeTable
3900 };
3901 static const char * const names[] = {
3902 "color"
3903 };
3904 static const ::flatbuffers::TypeTable tt = {
3905 ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
3906 };
3907 return &tt;
3908}
3909
3910inline const ::flatbuffers::TypeTable *Vec3TypeTable() {
3911 static const ::flatbuffers::TypeCode type_codes[] = {
3912 { ::flatbuffers::ET_FLOAT, 0, -1 },
3913 { ::flatbuffers::ET_FLOAT, 0, -1 },
3914 { ::flatbuffers::ET_FLOAT, 0, -1 },
3915 { ::flatbuffers::ET_DOUBLE, 0, -1 },
3916 { ::flatbuffers::ET_UCHAR, 0, 0 },
3917 { ::flatbuffers::ET_SEQUENCE, 0, 1 }
3918 };
3919 static const ::flatbuffers::TypeFunction type_refs[] = {
3920 MyGame::Example::ColorTypeTable,
3921 MyGame::Example::TestTypeTable
3922 };
3923 static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 };
3924 static const char * const names[] = {
3925 "x",
3926 "y",
3927 "z",
3928 "test1",
3929 "test2",
3930 "test3"
3931 };
3932 static const ::flatbuffers::TypeTable tt = {
3933 ::flatbuffers::ST_STRUCT, 6, type_codes, type_refs, nullptr, values, names
3934 };
3935 return &tt;
3936}
3937
3938inline const ::flatbuffers::TypeTable *AbilityTypeTable() {
3939 static const ::flatbuffers::TypeCode type_codes[] = {
3940 { ::flatbuffers::ET_UINT, 0, -1 },
3941 { ::flatbuffers::ET_UINT, 0, -1 }
3942 };
3943 static const int64_t values[] = { 0, 4, 8 };
3944 static const char * const names[] = {
3945 "id",
3946 "distance"
3947 };
3948 static const ::flatbuffers::TypeTable tt = {
3949 ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
3950 };
3951 return &tt;
3952}
3953
3954inline const ::flatbuffers::TypeTable *StructOfStructsTypeTable() {
3955 static const ::flatbuffers::TypeCode type_codes[] = {
3956 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
3957 { ::flatbuffers::ET_SEQUENCE, 0, 1 },
3958 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3959 };
3960 static const ::flatbuffers::TypeFunction type_refs[] = {
3961 MyGame::Example::AbilityTypeTable,
3962 MyGame::Example::TestTypeTable
3963 };
3964 static const int64_t values[] = { 0, 8, 12, 20 };
3965 static const char * const names[] = {
3966 "a",
3967 "b",
3968 "c"
3969 };
3970 static const ::flatbuffers::TypeTable tt = {
3971 ::flatbuffers::ST_STRUCT, 3, type_codes, type_refs, nullptr, values, names
3972 };
3973 return &tt;
3974}
3975
3976inline const ::flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() {
3977 static const ::flatbuffers::TypeCode type_codes[] = {
3978 { ::flatbuffers::ET_SEQUENCE, 0, 0 }
3979 };
3980 static const ::flatbuffers::TypeFunction type_refs[] = {
3981 MyGame::Example::StructOfStructsTypeTable
3982 };
3983 static const int64_t values[] = { 0, 20 };
3984 static const char * const names[] = {
3985 "a"
3986 };
3987 static const ::flatbuffers::TypeTable tt = {
3988 ::flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, names
3989 };
3990 return &tt;
3991}
3992
3993inline const ::flatbuffers::TypeTable *StatTypeTable() {
3994 static const ::flatbuffers::TypeCode type_codes[] = {
3995 { ::flatbuffers::ET_STRING, 0, -1 },
3996 { ::flatbuffers::ET_LONG, 0, -1 },
3997 { ::flatbuffers::ET_USHORT, 0, -1 }
3998 };
3999 static const char * const names[] = {
4000 "id",
4001 "val",
4002 "count"
4003 };
4004 static const ::flatbuffers::TypeTable tt = {
4005 ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
4006 };
4007 return &tt;
4008}
4009
4010inline const ::flatbuffers::TypeTable *ReferrableTypeTable() {
4011 static const ::flatbuffers::TypeCode type_codes[] = {
4012 { ::flatbuffers::ET_ULONG, 0, -1 }
4013 };
4014 static const char * const names[] = {
4015 "id"
4016 };
4017 static const ::flatbuffers::TypeTable tt = {
4018 ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
4019 };
4020 return &tt;
4021}
4022
4023inline const ::flatbuffers::TypeTable *MonsterTypeTable() {
4024 static const ::flatbuffers::TypeCode type_codes[] = {
4025 { ::flatbuffers::ET_SEQUENCE, 0, 0 },
4026 { ::flatbuffers::ET_SHORT, 0, -1 },
4027 { ::flatbuffers::ET_SHORT, 0, -1 },
4028 { ::flatbuffers::ET_STRING, 0, -1 },
4029 { ::flatbuffers::ET_BOOL, 0, -1 },
4030 { ::flatbuffers::ET_UCHAR, 1, -1 },
4031 { ::flatbuffers::ET_UCHAR, 0, 1 },
4032 { ::flatbuffers::ET_UTYPE, 0, 2 },
4033 { ::flatbuffers::ET_SEQUENCE, 0, 2 },
4034 { ::flatbuffers::ET_SEQUENCE, 1, 3 },
4035 { ::flatbuffers::ET_STRING, 1, -1 },
4036 { ::flatbuffers::ET_SEQUENCE, 1, 4 },
4037 { ::flatbuffers::ET_SEQUENCE, 0, 4 },
4038 { ::flatbuffers::ET_UCHAR, 1, -1 },
4039 { ::flatbuffers::ET_SEQUENCE, 0, 5 },
4040 { ::flatbuffers::ET_BOOL, 0, -1 },
4041 { ::flatbuffers::ET_INT, 0, -1 },
4042 { ::flatbuffers::ET_UINT, 0, -1 },
4043 { ::flatbuffers::ET_LONG, 0, -1 },
4044 { ::flatbuffers::ET_ULONG, 0, -1 },
4045 { ::flatbuffers::ET_INT, 0, -1 },
4046 { ::flatbuffers::ET_UINT, 0, -1 },
4047 { ::flatbuffers::ET_LONG, 0, -1 },
4048 { ::flatbuffers::ET_ULONG, 0, -1 },
4049 { ::flatbuffers::ET_BOOL, 1, -1 },
4050 { ::flatbuffers::ET_FLOAT, 0, -1 },
4051 { ::flatbuffers::ET_FLOAT, 0, -1 },
4052 { ::flatbuffers::ET_FLOAT, 0, -1 },
4053 { ::flatbuffers::ET_STRING, 1, -1 },
4054 { ::flatbuffers::ET_SEQUENCE, 1, 6 },
4055 { ::flatbuffers::ET_UCHAR, 1, -1 },
4056 { ::flatbuffers::ET_SEQUENCE, 1, 3 },
4057 { ::flatbuffers::ET_LONG, 1, -1 },
4058 { ::flatbuffers::ET_DOUBLE, 1, -1 },
4059 { ::flatbuffers::ET_SEQUENCE, 0, 7 },
4060 { ::flatbuffers::ET_SEQUENCE, 1, 8 },
4061 { ::flatbuffers::ET_ULONG, 0, -1 },
4062 { ::flatbuffers::ET_ULONG, 1, -1 },
4063 { ::flatbuffers::ET_SEQUENCE, 1, 8 },
4064 { ::flatbuffers::ET_ULONG, 0, -1 },
4065 { ::flatbuffers::ET_ULONG, 1, -1 },
4066 { ::flatbuffers::ET_ULONG, 0, -1 },
4067 { ::flatbuffers::ET_ULONG, 1, -1 },
4068 { ::flatbuffers::ET_UTYPE, 0, 9 },
4069 { ::flatbuffers::ET_SEQUENCE, 0, 9 },
4070 { ::flatbuffers::ET_UTYPE, 0, 10 },
4071 { ::flatbuffers::ET_SEQUENCE, 0, 10 },
4072 { ::flatbuffers::ET_UCHAR, 1, 1 },
4073 { ::flatbuffers::ET_CHAR, 0, 11 },
4074 { ::flatbuffers::ET_UCHAR, 1, -1 },
4075 { ::flatbuffers::ET_SEQUENCE, 1, 5 },
4076 { ::flatbuffers::ET_SEQUENCE, 0, 3 },
4077 { ::flatbuffers::ET_ULONG, 0, 12 },
4078 { ::flatbuffers::ET_ULONG, 0, 12 },
4079 { ::flatbuffers::ET_FLOAT, 0, -1 },
4080 { ::flatbuffers::ET_FLOAT, 0, -1 },
4081 { ::flatbuffers::ET_FLOAT, 0, -1 },
4082 { ::flatbuffers::ET_FLOAT, 0, -1 },
4083 { ::flatbuffers::ET_FLOAT, 0, -1 },
4084 { ::flatbuffers::ET_FLOAT, 0, -1 },
4085 { ::flatbuffers::ET_FLOAT, 0, -1 },
4086 { ::flatbuffers::ET_DOUBLE, 0, -1 }
4087 };
4088 static const ::flatbuffers::TypeFunction type_refs[] = {
4089 MyGame::Example::Vec3TypeTable,
4090 MyGame::Example::ColorTypeTable,
4091 MyGame::Example::AnyTypeTable,
4092 MyGame::Example::TestTypeTable,
4093 MyGame::Example::MonsterTypeTable,
4094 MyGame::Example::StatTypeTable,
4095 MyGame::Example::AbilityTypeTable,
4096 MyGame::InParentNamespaceTypeTable,
4097 MyGame::Example::ReferrableTypeTable,
4098 MyGame::Example::AnyUniqueAliasesTypeTable,
4099 MyGame::Example::AnyAmbiguousAliasesTypeTable,
4100 MyGame::Example::RaceTypeTable,
4101 MyGame::Example::LongEnumTypeTable
4102 };
4103 static const char * const names[] = {
4104 "pos",
4105 "mana",
4106 "hp",
4107 "name",
4108 "friendly",
4109 "inventory",
4110 "color",
4111 "test_type",
4112 "test",
4113 "test4",
4114 "testarrayofstring",
4115 "testarrayoftables",
4116 "enemy",
4117 "testnestedflatbuffer",
4118 "testempty",
4119 "testbool",
4120 "testhashs32_fnv1",
4121 "testhashu32_fnv1",
4122 "testhashs64_fnv1",
4123 "testhashu64_fnv1",
4124 "testhashs32_fnv1a",
4125 "testhashu32_fnv1a",
4126 "testhashs64_fnv1a",
4127 "testhashu64_fnv1a",
4128 "testarrayofbools",
4129 "testf",
4130 "testf2",
4131 "testf3",
4132 "testarrayofstring2",
4133 "testarrayofsortedstruct",
4134 "flex",
4135 "test5",
4136 "vector_of_longs",
4137 "vector_of_doubles",
4138 "parent_namespace_test",
4139 "vector_of_referrables",
4140 "single_weak_reference",
4141 "vector_of_weak_references",
4142 "vector_of_strong_referrables",
4143 "co_owning_reference",
4144 "vector_of_co_owning_references",
4145 "non_owning_reference",
4146 "vector_of_non_owning_references",
4147 "any_unique_type",
4148 "any_unique",
4149 "any_ambiguous_type",
4150 "any_ambiguous",
4151 "vector_of_enums",
4152 "signed_enum",
4153 "testrequirednestedflatbuffer",
4154 "scalar_key_sorted_tables",
4155 "native_inline",
4156 "long_enum_non_enum_default",
4157 "long_enum_normal_default",
4158 "nan_default",
4159 "inf_default",
4160 "positive_inf_default",
4161 "infinity_default",
4162 "positive_infinity_default",
4163 "negative_inf_default",
4164 "negative_infinity_default",
4165 "double_inf_default"
4166 };
4167 static const ::flatbuffers::TypeTable tt = {
4168 ::flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
4169 };
4170 return &tt;
4171}
4172
4173inline const ::flatbuffers::TypeTable *TypeAliasesTypeTable() {
4174 static const ::flatbuffers::TypeCode type_codes[] = {
4175 { ::flatbuffers::ET_CHAR, 0, -1 },
4176 { ::flatbuffers::ET_UCHAR, 0, -1 },
4177 { ::flatbuffers::ET_SHORT, 0, -1 },
4178 { ::flatbuffers::ET_USHORT, 0, -1 },
4179 { ::flatbuffers::ET_INT, 0, -1 },
4180 { ::flatbuffers::ET_UINT, 0, -1 },
4181 { ::flatbuffers::ET_LONG, 0, -1 },
4182 { ::flatbuffers::ET_ULONG, 0, -1 },
4183 { ::flatbuffers::ET_FLOAT, 0, -1 },
4184 { ::flatbuffers::ET_DOUBLE, 0, -1 },
4185 { ::flatbuffers::ET_CHAR, 1, -1 },
4186 { ::flatbuffers::ET_DOUBLE, 1, -1 }
4187 };
4188 static const char * const names[] = {
4189 "i8",
4190 "u8",
4191 "i16",
4192 "u16",
4193 "i32",
4194 "u32",
4195 "i64",
4196 "u64",
4197 "f32",
4198 "f64",
4199 "v8",
4200 "vf64"
4201 };
4202 static const ::flatbuffers::TypeTable tt = {
4203 ::flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, nullptr, names
4204 };
4205 return &tt;
4206}
4207
4208inline const MyGame::Example::Monster *GetMonster(const void *buf) {
4209 return ::flatbuffers::GetRoot<MyGame::Example::Monster>(buf);
4210}
4211
4212inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) {
4213 return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::Monster>(buf);
4214}
4215
4216inline Monster *GetMutableMonster(void *buf) {
4217 return ::flatbuffers::GetMutableRoot<Monster>(buf);
4218}
4219
4220inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) {
4221 return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::Monster>(buf);
4222}
4223
4224inline const char *MonsterIdentifier() {
4225 return "MONS";
4226}
4227
4228inline bool MonsterBufferHasIdentifier(const void *buf) {
4229 return ::flatbuffers::BufferHasIdentifier(
4230 buf, MonsterIdentifier());
4231}
4232
4233inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
4234 return ::flatbuffers::BufferHasIdentifier(
4235 buf, MonsterIdentifier(), true);
4236}
4237
4238inline bool VerifyMonsterBuffer(
4239 ::flatbuffers::Verifier &verifier) {
4240 return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
4241}
4242
4243inline bool VerifySizePrefixedMonsterBuffer(
4244 ::flatbuffers::Verifier &verifier) {
4245 return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
4246}
4247
4248inline const char *MonsterExtension() {
4249 return "mon";
4250}
4251
4252inline void FinishMonsterBuffer(
4253 ::flatbuffers::FlatBufferBuilder &fbb,
4254 ::flatbuffers::Offset<MyGame::Example::Monster> root) {
4255 fbb.Finish(root, MonsterIdentifier());
4256}
4257
4258inline void FinishSizePrefixedMonsterBuffer(
4259 ::flatbuffers::FlatBufferBuilder &fbb,
4260 ::flatbuffers::Offset<MyGame::Example::Monster> root) {
4261 fbb.FinishSizePrefixed(root, MonsterIdentifier());
4262}
4263
4264inline std::unique_ptr<MyGame::Example::MonsterT> UnPackMonster(
4265 const void *buf,
4266 const ::flatbuffers::resolver_function_t *res = nullptr) {
4267 return std::unique_ptr<MyGame::Example::MonsterT>(GetMonster(buf)->UnPack(res));
4268}
4269
4270inline std::unique_ptr<MyGame::Example::MonsterT> UnPackSizePrefixedMonster(
4271 const void *buf,
4272 const ::flatbuffers::resolver_function_t *res = nullptr) {
4273 return std::unique_ptr<MyGame::Example::MonsterT>(GetSizePrefixedMonster(buf)->UnPack(res));
4274}
4275
4276} // namespace Example
4277} // namespace MyGame
4278
4279#endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
View as plain text