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
10 namespace MyGame {
11
12 struct InParentNamespace;
13 struct InParentNamespaceT;
14
15 namespace Example2 {
16
17 struct Monster;
18 struct MonsterT;
19
20 } // namespace Example2
21
22 namespace Example {
23
24 struct Test;
25
26 struct TestSimpleTableWithEnum;
27 struct TestSimpleTableWithEnumT;
28
29 struct Vec3;
30
31 struct Ability;
32
33 struct Stat;
34 struct StatT;
35
36 struct Referrable;
37 struct ReferrableT;
38
39 struct Monster;
40 struct MonsterT;
41
42 struct TypeAliases;
43 struct TypeAliasesT;
44
45 } // namespace Example
46
47 bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs);
48 namespace Example2 {
49
50 bool operator==(const MonsterT &lhs, const MonsterT &rhs);
51 } // namespace Example2
52
53 namespace Example {
54
55 bool operator==(const Test &lhs, const Test &rhs);
56 bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs);
57 bool operator==(const Vec3 &lhs, const Vec3 &rhs);
58 bool operator==(const Ability &lhs, const Ability &rhs);
59 bool operator==(const StatT &lhs, const StatT &rhs);
60 bool operator==(const ReferrableT &lhs, const ReferrableT &rhs);
61 bool operator==(const MonsterT &lhs, const MonsterT &rhs);
62 bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs);
63
64 } // namespace Example
65
66 inline const flatbuffers::TypeTable *InParentNamespaceTypeTable();
67
68 namespace Example2 {
69
70 inline const flatbuffers::TypeTable *MonsterTypeTable();
71
72 } // namespace Example2
73
74 namespace Example {
75
76 inline const flatbuffers::TypeTable *TestTypeTable();
77
78 inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable();
79
80 inline const flatbuffers::TypeTable *Vec3TypeTable();
81
82 inline const flatbuffers::TypeTable *AbilityTypeTable();
83
84 inline const flatbuffers::TypeTable *StatTypeTable();
85
86 inline const flatbuffers::TypeTable *ReferrableTypeTable();
87
88 inline const flatbuffers::TypeTable *MonsterTypeTable();
89
90 inline const flatbuffers::TypeTable *TypeAliasesTypeTable();
91
92 enum Color {
93 Color_Red = 1,
94 Color_Green = 2,
95 Color_Blue = 8,
96 Color_NONE = 0,
97 Color_ANY = 11
98 };
99
EnumValuesColor()100 inline const Color (&EnumValuesColor())[3] {
101 static const Color values[] = {
102 Color_Red,
103 Color_Green,
104 Color_Blue
105 };
106 return values;
107 }
108
EnumNamesColor()109 inline const char * const *EnumNamesColor() {
110 static const char * const names[] = {
111 "Red",
112 "Green",
113 "",
114 "",
115 "",
116 "",
117 "",
118 "Blue",
119 nullptr
120 };
121 return names;
122 }
123
EnumNameColor(Color e)124 inline const char *EnumNameColor(Color e) {
125 if (e < Color_Red || e > Color_Blue) return "";
126 const size_t index = static_cast<int>(e) - static_cast<int>(Color_Red);
127 return EnumNamesColor()[index];
128 }
129
130 enum Any {
131 Any_NONE = 0,
132 Any_Monster = 1,
133 Any_TestSimpleTableWithEnum = 2,
134 Any_MyGame_Example2_Monster = 3,
135 Any_MIN = Any_NONE,
136 Any_MAX = Any_MyGame_Example2_Monster
137 };
138
EnumValuesAny()139 inline const Any (&EnumValuesAny())[4] {
140 static const Any values[] = {
141 Any_NONE,
142 Any_Monster,
143 Any_TestSimpleTableWithEnum,
144 Any_MyGame_Example2_Monster
145 };
146 return values;
147 }
148
EnumNamesAny()149 inline const char * const *EnumNamesAny() {
150 static const char * const names[] = {
151 "NONE",
152 "Monster",
153 "TestSimpleTableWithEnum",
154 "MyGame_Example2_Monster",
155 nullptr
156 };
157 return names;
158 }
159
EnumNameAny(Any e)160 inline const char *EnumNameAny(Any e) {
161 if (e < Any_NONE || e > Any_MyGame_Example2_Monster) return "";
162 const size_t index = static_cast<int>(e);
163 return EnumNamesAny()[index];
164 }
165
166 template<typename T> struct AnyTraits {
167 static const Any enum_value = Any_NONE;
168 };
169
170 template<> struct AnyTraits<Monster> {
171 static const Any enum_value = Any_Monster;
172 };
173
174 template<> struct AnyTraits<TestSimpleTableWithEnum> {
175 static const Any enum_value = Any_TestSimpleTableWithEnum;
176 };
177
178 template<> struct AnyTraits<MyGame::Example2::Monster> {
179 static const Any enum_value = Any_MyGame_Example2_Monster;
180 };
181
182 struct AnyUnion {
183 Any type;
184 void *value;
185
186 AnyUnion() : type(Any_NONE), value(nullptr) {}
187 AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT :
188 type(Any_NONE), value(nullptr)
189 { std::swap(type, u.type); std::swap(value, u.value); }
190 AnyUnion(const AnyUnion &) FLATBUFFERS_NOEXCEPT;
191 AnyUnion &operator=(const AnyUnion &u) FLATBUFFERS_NOEXCEPT
192 { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
193 AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT
194 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
195 ~AnyUnion() { Reset(); }
196
197 void Reset();
198
199 #ifndef FLATBUFFERS_CPP98_STL
200 template <typename T>
201 void Set(T&& val) {
202 Reset();
203 type = AnyTraits<typename T::TableType>::enum_value;
204 if (type != Any_NONE) {
205 value = new T(std::forward<T>(val));
206 }
207 }
208 #endif // FLATBUFFERS_CPP98_STL
209
210 static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver);
211 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
212
213 MonsterT *AsMonster() {
214 return type == Any_Monster ?
215 reinterpret_cast<MonsterT *>(value) : nullptr;
216 }
217 const MonsterT *AsMonster() const {
218 return type == Any_Monster ?
219 reinterpret_cast<const MonsterT *>(value) : nullptr;
220 }
221 TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() {
222 return type == Any_TestSimpleTableWithEnum ?
223 reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
224 }
225 const TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const {
226 return type == Any_TestSimpleTableWithEnum ?
227 reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr;
228 }
229 MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() {
230 return type == Any_MyGame_Example2_Monster ?
231 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
232 }
233 const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const {
234 return type == Any_MyGame_Example2_Monster ?
235 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr;
236 }
237 };
238
239
240 inline bool operator==(const AnyUnion &lhs, const AnyUnion &rhs) {
241 if (lhs.type != rhs.type) return false;
242 switch (lhs.type) {
243 case Any_NONE: {
244 return true;
245 }
246 case Any_Monster: {
247 return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
248 *(reinterpret_cast<const MonsterT *>(rhs.value));
249 }
250 case Any_TestSimpleTableWithEnum: {
251 return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) ==
252 *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value));
253 }
254 case Any_MyGame_Example2_Monster: {
255 return *(reinterpret_cast<const MyGame::Example2::MonsterT *>(lhs.value)) ==
256 *(reinterpret_cast<const MyGame::Example2::MonsterT *>(rhs.value));
257 }
258 default: {
259 return false;
260 }
261 }
262 }
263 bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type);
264 bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
265
266 enum AnyUniqueAliases {
267 AnyUniqueAliases_NONE = 0,
268 AnyUniqueAliases_M = 1,
269 AnyUniqueAliases_T = 2,
270 AnyUniqueAliases_M2 = 3,
271 AnyUniqueAliases_MIN = AnyUniqueAliases_NONE,
272 AnyUniqueAliases_MAX = AnyUniqueAliases_M2
273 };
274
275 inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] {
276 static const AnyUniqueAliases values[] = {
277 AnyUniqueAliases_NONE,
278 AnyUniqueAliases_M,
279 AnyUniqueAliases_T,
280 AnyUniqueAliases_M2
281 };
282 return values;
283 }
284
285 inline const char * const *EnumNamesAnyUniqueAliases() {
286 static const char * const names[] = {
287 "NONE",
288 "M",
289 "T",
290 "M2",
291 nullptr
292 };
293 return names;
294 }
295
296 inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) {
297 if (e < AnyUniqueAliases_NONE || e > AnyUniqueAliases_M2) return "";
298 const size_t index = static_cast<int>(e);
299 return EnumNamesAnyUniqueAliases()[index];
300 }
301
302 template<typename T> struct AnyUniqueAliasesTraits {
303 static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE;
304 };
305
306 template<> struct AnyUniqueAliasesTraits<Monster> {
307 static const AnyUniqueAliases enum_value = AnyUniqueAliases_M;
308 };
309
310 template<> struct AnyUniqueAliasesTraits<TestSimpleTableWithEnum> {
311 static const AnyUniqueAliases enum_value = AnyUniqueAliases_T;
312 };
313
314 template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> {
315 static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2;
316 };
317
318 struct AnyUniqueAliasesUnion {
319 AnyUniqueAliases type;
320 void *value;
321
322 AnyUniqueAliasesUnion() : type(AnyUniqueAliases_NONE), value(nullptr) {}
323 AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT :
324 type(AnyUniqueAliases_NONE), value(nullptr)
325 { std::swap(type, u.type); std::swap(value, u.value); }
326 AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &) FLATBUFFERS_NOEXCEPT;
327 AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u) FLATBUFFERS_NOEXCEPT
328 { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
329 AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT
330 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
331 ~AnyUniqueAliasesUnion() { Reset(); }
332
333 void Reset();
334
335 #ifndef FLATBUFFERS_CPP98_STL
336 template <typename T>
337 void Set(T&& val) {
338 Reset();
339 type = AnyUniqueAliasesTraits<typename T::TableType>::enum_value;
340 if (type != AnyUniqueAliases_NONE) {
341 value = new T(std::forward<T>(val));
342 }
343 }
344 #endif // FLATBUFFERS_CPP98_STL
345
346 static void *UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver);
347 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
348
349 MonsterT *AsM() {
350 return type == AnyUniqueAliases_M ?
351 reinterpret_cast<MonsterT *>(value) : nullptr;
352 }
353 const MonsterT *AsM() const {
354 return type == AnyUniqueAliases_M ?
355 reinterpret_cast<const MonsterT *>(value) : nullptr;
356 }
357 TestSimpleTableWithEnumT *AsT() {
358 return type == AnyUniqueAliases_T ?
359 reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
360 }
361 const TestSimpleTableWithEnumT *AsT() const {
362 return type == AnyUniqueAliases_T ?
363 reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr;
364 }
365 MyGame::Example2::MonsterT *AsM2() {
366 return type == AnyUniqueAliases_M2 ?
367 reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
368 }
369 const MyGame::Example2::MonsterT *AsM2() const {
370 return type == AnyUniqueAliases_M2 ?
371 reinterpret_cast<const MyGame::Example2::MonsterT *>(value) : nullptr;
372 }
373 };
374
375
376 inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) {
377 if (lhs.type != rhs.type) return false;
378 switch (lhs.type) {
379 case AnyUniqueAliases_NONE: {
380 return true;
381 }
382 case AnyUniqueAliases_M: {
383 return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
384 *(reinterpret_cast<const MonsterT *>(rhs.value));
385 }
386 case AnyUniqueAliases_T: {
387 return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) ==
388 *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value));
389 }
390 case AnyUniqueAliases_M2: {
391 return *(reinterpret_cast<const MyGame::Example2::MonsterT *>(lhs.value)) ==
392 *(reinterpret_cast<const MyGame::Example2::MonsterT *>(rhs.value));
393 }
394 default: {
395 return false;
396 }
397 }
398 }
399 bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
400 bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
401
402 enum AnyAmbiguousAliases {
403 AnyAmbiguousAliases_NONE = 0,
404 AnyAmbiguousAliases_M1 = 1,
405 AnyAmbiguousAliases_M2 = 2,
406 AnyAmbiguousAliases_M3 = 3,
407 AnyAmbiguousAliases_MIN = AnyAmbiguousAliases_NONE,
408 AnyAmbiguousAliases_MAX = AnyAmbiguousAliases_M3
409 };
410
411 inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] {
412 static const AnyAmbiguousAliases values[] = {
413 AnyAmbiguousAliases_NONE,
414 AnyAmbiguousAliases_M1,
415 AnyAmbiguousAliases_M2,
416 AnyAmbiguousAliases_M3
417 };
418 return values;
419 }
420
421 inline const char * const *EnumNamesAnyAmbiguousAliases() {
422 static const char * const names[] = {
423 "NONE",
424 "M1",
425 "M2",
426 "M3",
427 nullptr
428 };
429 return names;
430 }
431
432 inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) {
433 if (e < AnyAmbiguousAliases_NONE || e > AnyAmbiguousAliases_M3) return "";
434 const size_t index = static_cast<int>(e);
435 return EnumNamesAnyAmbiguousAliases()[index];
436 }
437
438 struct AnyAmbiguousAliasesUnion {
439 AnyAmbiguousAliases type;
440 void *value;
441
442 AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases_NONE), value(nullptr) {}
443 AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT :
444 type(AnyAmbiguousAliases_NONE), value(nullptr)
445 { std::swap(type, u.type); std::swap(value, u.value); }
446 AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &) FLATBUFFERS_NOEXCEPT;
447 AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u) FLATBUFFERS_NOEXCEPT
448 { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
449 AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT
450 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
451 ~AnyAmbiguousAliasesUnion() { Reset(); }
452
453 void Reset();
454
455 static void *UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver);
456 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
457
458 MonsterT *AsM1() {
459 return type == AnyAmbiguousAliases_M1 ?
460 reinterpret_cast<MonsterT *>(value) : nullptr;
461 }
462 const MonsterT *AsM1() const {
463 return type == AnyAmbiguousAliases_M1 ?
464 reinterpret_cast<const MonsterT *>(value) : nullptr;
465 }
466 MonsterT *AsM2() {
467 return type == AnyAmbiguousAliases_M2 ?
468 reinterpret_cast<MonsterT *>(value) : nullptr;
469 }
470 const MonsterT *AsM2() const {
471 return type == AnyAmbiguousAliases_M2 ?
472 reinterpret_cast<const MonsterT *>(value) : nullptr;
473 }
474 MonsterT *AsM3() {
475 return type == AnyAmbiguousAliases_M3 ?
476 reinterpret_cast<MonsterT *>(value) : nullptr;
477 }
478 const MonsterT *AsM3() const {
479 return type == AnyAmbiguousAliases_M3 ?
480 reinterpret_cast<const MonsterT *>(value) : nullptr;
481 }
482 };
483
484
485 inline bool operator==(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) {
486 if (lhs.type != rhs.type) return false;
487 switch (lhs.type) {
488 case AnyAmbiguousAliases_NONE: {
489 return true;
490 }
491 case AnyAmbiguousAliases_M1: {
492 return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
493 *(reinterpret_cast<const MonsterT *>(rhs.value));
494 }
495 case AnyAmbiguousAliases_M2: {
496 return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
497 *(reinterpret_cast<const MonsterT *>(rhs.value));
498 }
499 case AnyAmbiguousAliases_M3: {
500 return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
501 *(reinterpret_cast<const MonsterT *>(rhs.value));
502 }
503 default: {
504 return false;
505 }
506 }
507 }
508 bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
509 bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
510
511 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
512 private:
513 int16_t a_;
514 int8_t b_;
515 int8_t padding0__;
516
517 public:
518 Test() {
519 memset(static_cast<void *>(this), 0, sizeof(Test));
520 }
521 Test(int16_t _a, int8_t _b)
522 : a_(flatbuffers::EndianScalar(_a)),
523 b_(flatbuffers::EndianScalar(_b)),
524 padding0__(0) {
525 (void)padding0__;
526 }
527 int16_t a() const {
528 return flatbuffers::EndianScalar(a_);
529 }
530 void mutate_a(int16_t _a) {
531 flatbuffers::WriteScalar(&a_, _a);
532 }
533 int8_t b() const {
534 return flatbuffers::EndianScalar(b_);
535 }
536 void mutate_b(int8_t _b) {
537 flatbuffers::WriteScalar(&b_, _b);
538 }
539 };
540 FLATBUFFERS_STRUCT_END(Test, 4);
541
542 inline bool operator==(const Test &lhs, const Test &rhs) {
543 return
544 (lhs.a() == rhs.a()) &&
545 (lhs.b() == rhs.b());
546 }
547
548 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS {
549 private:
550 float x_;
551 float y_;
552 float z_;
553 int32_t padding0__;
554 double test1_;
555 int8_t test2_;
556 int8_t padding1__;
557 Test test3_;
558 int16_t padding2__;
559
560 public:
561 Vec3() {
562 memset(static_cast<void *>(this), 0, sizeof(Vec3));
563 }
564 Vec3(float _x, float _y, float _z, double _test1, Color _test2, const Test &_test3)
565 : x_(flatbuffers::EndianScalar(_x)),
566 y_(flatbuffers::EndianScalar(_y)),
567 z_(flatbuffers::EndianScalar(_z)),
568 padding0__(0),
569 test1_(flatbuffers::EndianScalar(_test1)),
570 test2_(flatbuffers::EndianScalar(static_cast<int8_t>(_test2))),
571 padding1__(0),
572 test3_(_test3),
573 padding2__(0) {
574 (void)padding0__;
575 (void)padding1__;
576 (void)padding2__;
577 }
578 float x() const {
579 return flatbuffers::EndianScalar(x_);
580 }
581 void mutate_x(float _x) {
582 flatbuffers::WriteScalar(&x_, _x);
583 }
584 float y() const {
585 return flatbuffers::EndianScalar(y_);
586 }
587 void mutate_y(float _y) {
588 flatbuffers::WriteScalar(&y_, _y);
589 }
590 float z() const {
591 return flatbuffers::EndianScalar(z_);
592 }
593 void mutate_z(float _z) {
594 flatbuffers::WriteScalar(&z_, _z);
595 }
596 double test1() const {
597 return flatbuffers::EndianScalar(test1_);
598 }
599 void mutate_test1(double _test1) {
600 flatbuffers::WriteScalar(&test1_, _test1);
601 }
602 Color test2() const {
603 return static_cast<Color>(flatbuffers::EndianScalar(test2_));
604 }
605 void mutate_test2(Color _test2) {
606 flatbuffers::WriteScalar(&test2_, static_cast<int8_t>(_test2));
607 }
608 const Test &test3() const {
609 return test3_;
610 }
611 Test &mutable_test3() {
612 return test3_;
613 }
614 };
615 FLATBUFFERS_STRUCT_END(Vec3, 32);
616
617 inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) {
618 return
619 (lhs.x() == rhs.x()) &&
620 (lhs.y() == rhs.y()) &&
621 (lhs.z() == rhs.z()) &&
622 (lhs.test1() == rhs.test1()) &&
623 (lhs.test2() == rhs.test2()) &&
624 (lhs.test3() == rhs.test3());
625 }
626
627 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS {
628 private:
629 uint32_t id_;
630 uint32_t distance_;
631
632 public:
633 Ability() {
634 memset(static_cast<void *>(this), 0, sizeof(Ability));
635 }
636 Ability(uint32_t _id, uint32_t _distance)
637 : id_(flatbuffers::EndianScalar(_id)),
638 distance_(flatbuffers::EndianScalar(_distance)) {
639 }
640 uint32_t id() const {
641 return flatbuffers::EndianScalar(id_);
642 }
643 void mutate_id(uint32_t _id) {
644 flatbuffers::WriteScalar(&id_, _id);
645 }
646 bool KeyCompareLessThan(const Ability *o) const {
647 return id() < o->id();
648 }
649 int KeyCompareWithValue(uint32_t val) const {
650 return static_cast<int>(id() > val) - static_cast<int>(id() < val);
651 }
652 uint32_t distance() const {
653 return flatbuffers::EndianScalar(distance_);
654 }
655 void mutate_distance(uint32_t _distance) {
656 flatbuffers::WriteScalar(&distance_, _distance);
657 }
658 };
659 FLATBUFFERS_STRUCT_END(Ability, 8);
660
661 inline bool operator==(const Ability &lhs, const Ability &rhs) {
662 return
663 (lhs.id() == rhs.id()) &&
664 (lhs.distance() == rhs.distance());
665 }
666
667 } // namespace Example
668
669 struct InParentNamespaceT : public flatbuffers::NativeTable {
670 typedef InParentNamespace TableType;
671 InParentNamespaceT() {
672 }
673 };
674
675 inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) {
676 return true;
677 }
678
679 struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
680 typedef InParentNamespaceT NativeTableType;
681 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
682 return InParentNamespaceTypeTable();
683 }
684 bool Verify(flatbuffers::Verifier &verifier) const {
685 return VerifyTableStart(verifier) &&
686 verifier.EndTable();
687 }
688 InParentNamespaceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
689 void UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
690 static flatbuffers::Offset<InParentNamespace> Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
691 };
692
693 struct InParentNamespaceBuilder {
694 flatbuffers::FlatBufferBuilder &fbb_;
695 flatbuffers::uoffset_t start_;
696 explicit InParentNamespaceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
697 : fbb_(_fbb) {
698 start_ = fbb_.StartTable();
699 }
700 InParentNamespaceBuilder &operator=(const InParentNamespaceBuilder &);
701 flatbuffers::Offset<InParentNamespace> Finish() {
702 const auto end = fbb_.EndTable(start_);
703 auto o = flatbuffers::Offset<InParentNamespace>(end);
704 return o;
705 }
706 };
707
708 inline flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(
709 flatbuffers::FlatBufferBuilder &_fbb) {
710 InParentNamespaceBuilder builder_(_fbb);
711 return builder_.Finish();
712 }
713
714 flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
715
716 namespace Example2 {
717
718 struct MonsterT : public flatbuffers::NativeTable {
719 typedef Monster TableType;
720 MonsterT() {
721 }
722 };
723
724 inline bool operator==(const MonsterT &, const MonsterT &) {
725 return true;
726 }
727
728 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
729 typedef MonsterT NativeTableType;
730 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
731 return MonsterTypeTable();
732 }
733 bool Verify(flatbuffers::Verifier &verifier) const {
734 return VerifyTableStart(verifier) &&
735 verifier.EndTable();
736 }
737 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
738 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
739 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
740 };
741
742 struct MonsterBuilder {
743 flatbuffers::FlatBufferBuilder &fbb_;
744 flatbuffers::uoffset_t start_;
745 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
746 : fbb_(_fbb) {
747 start_ = fbb_.StartTable();
748 }
749 MonsterBuilder &operator=(const MonsterBuilder &);
750 flatbuffers::Offset<Monster> Finish() {
751 const auto end = fbb_.EndTable(start_);
752 auto o = flatbuffers::Offset<Monster>(end);
753 return o;
754 }
755 };
756
757 inline flatbuffers::Offset<Monster> CreateMonster(
758 flatbuffers::FlatBufferBuilder &_fbb) {
759 MonsterBuilder builder_(_fbb);
760 return builder_.Finish();
761 }
762
763 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
764
765 } // namespace Example2
766
767 namespace Example {
768
769 struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable {
770 typedef TestSimpleTableWithEnum TableType;
771 Color color;
772 TestSimpleTableWithEnumT()
773 : color(Color_Green) {
774 }
775 };
776
777 inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) {
778 return
779 (lhs.color == rhs.color);
780 }
781
782 struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
783 typedef TestSimpleTableWithEnumT NativeTableType;
784 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
785 return TestSimpleTableWithEnumTypeTable();
786 }
787 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
788 VT_COLOR = 4
789 };
790 Color color() const {
791 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 2));
792 }
793 bool mutate_color(Color _color) {
794 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2);
795 }
796 bool Verify(flatbuffers::Verifier &verifier) const {
797 return VerifyTableStart(verifier) &&
798 VerifyField<int8_t>(verifier, VT_COLOR) &&
799 verifier.EndTable();
800 }
801 TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
802 void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
803 static flatbuffers::Offset<TestSimpleTableWithEnum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
804 };
805
806 struct TestSimpleTableWithEnumBuilder {
807 flatbuffers::FlatBufferBuilder &fbb_;
808 flatbuffers::uoffset_t start_;
809 void add_color(Color color) {
810 fbb_.AddElement<int8_t>(TestSimpleTableWithEnum::VT_COLOR, static_cast<int8_t>(color), 2);
811 }
812 explicit TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb)
813 : fbb_(_fbb) {
814 start_ = fbb_.StartTable();
815 }
816 TestSimpleTableWithEnumBuilder &operator=(const TestSimpleTableWithEnumBuilder &);
817 flatbuffers::Offset<TestSimpleTableWithEnum> Finish() {
818 const auto end = fbb_.EndTable(start_);
819 auto o = flatbuffers::Offset<TestSimpleTableWithEnum>(end);
820 return o;
821 }
822 };
823
824 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(
825 flatbuffers::FlatBufferBuilder &_fbb,
826 Color color = Color_Green) {
827 TestSimpleTableWithEnumBuilder builder_(_fbb);
828 builder_.add_color(color);
829 return builder_.Finish();
830 }
831
832 flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
833
834 struct StatT : public flatbuffers::NativeTable {
835 typedef Stat TableType;
836 std::string id;
837 int64_t val;
838 uint16_t count;
839 StatT()
840 : val(0),
841 count(0) {
842 }
843 };
844
845 inline bool operator==(const StatT &lhs, const StatT &rhs) {
846 return
847 (lhs.id == rhs.id) &&
848 (lhs.val == rhs.val) &&
849 (lhs.count == rhs.count);
850 }
851
852 struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
853 typedef StatT NativeTableType;
854 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
855 return StatTypeTable();
856 }
857 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
858 VT_ID = 4,
859 VT_VAL = 6,
860 VT_COUNT = 8
861 };
862 const flatbuffers::String *id() const {
863 return GetPointer<const flatbuffers::String *>(VT_ID);
864 }
865 flatbuffers::String *mutable_id() {
866 return GetPointer<flatbuffers::String *>(VT_ID);
867 }
868 int64_t val() const {
869 return GetField<int64_t>(VT_VAL, 0);
870 }
871 bool mutate_val(int64_t _val) {
872 return SetField<int64_t>(VT_VAL, _val, 0);
873 }
874 uint16_t count() const {
875 return GetField<uint16_t>(VT_COUNT, 0);
876 }
877 bool mutate_count(uint16_t _count) {
878 return SetField<uint16_t>(VT_COUNT, _count, 0);
879 }
880 bool Verify(flatbuffers::Verifier &verifier) const {
881 return VerifyTableStart(verifier) &&
882 VerifyOffset(verifier, VT_ID) &&
883 verifier.VerifyString(id()) &&
884 VerifyField<int64_t>(verifier, VT_VAL) &&
885 VerifyField<uint16_t>(verifier, VT_COUNT) &&
886 verifier.EndTable();
887 }
888 StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
889 void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
890 static flatbuffers::Offset<Stat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
891 };
892
893 struct StatBuilder {
894 flatbuffers::FlatBufferBuilder &fbb_;
895 flatbuffers::uoffset_t start_;
896 void add_id(flatbuffers::Offset<flatbuffers::String> id) {
897 fbb_.AddOffset(Stat::VT_ID, id);
898 }
899 void add_val(int64_t val) {
900 fbb_.AddElement<int64_t>(Stat::VT_VAL, val, 0);
901 }
902 void add_count(uint16_t count) {
903 fbb_.AddElement<uint16_t>(Stat::VT_COUNT, count, 0);
904 }
905 explicit StatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
906 : fbb_(_fbb) {
907 start_ = fbb_.StartTable();
908 }
909 StatBuilder &operator=(const StatBuilder &);
910 flatbuffers::Offset<Stat> Finish() {
911 const auto end = fbb_.EndTable(start_);
912 auto o = flatbuffers::Offset<Stat>(end);
913 return o;
914 }
915 };
916
917 inline flatbuffers::Offset<Stat> CreateStat(
918 flatbuffers::FlatBufferBuilder &_fbb,
919 flatbuffers::Offset<flatbuffers::String> id = 0,
920 int64_t val = 0,
921 uint16_t count = 0) {
922 StatBuilder builder_(_fbb);
923 builder_.add_val(val);
924 builder_.add_id(id);
925 builder_.add_count(count);
926 return builder_.Finish();
927 }
928
929 inline flatbuffers::Offset<Stat> CreateStatDirect(
930 flatbuffers::FlatBufferBuilder &_fbb,
931 const char *id = nullptr,
932 int64_t val = 0,
933 uint16_t count = 0) {
934 auto id__ = id ? _fbb.CreateString(id) : 0;
935 return MyGame::Example::CreateStat(
936 _fbb,
937 id__,
938 val,
939 count);
940 }
941
942 flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
943
944 struct ReferrableT : public flatbuffers::NativeTable {
945 typedef Referrable TableType;
946 uint64_t id;
947 ReferrableT()
948 : id(0) {
949 }
950 };
951
952 inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) {
953 return
954 (lhs.id == rhs.id);
955 }
956
957 struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
958 typedef ReferrableT NativeTableType;
959 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
960 return ReferrableTypeTable();
961 }
962 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
963 VT_ID = 4
964 };
965 uint64_t id() const {
966 return GetField<uint64_t>(VT_ID, 0);
967 }
968 bool mutate_id(uint64_t _id) {
969 return SetField<uint64_t>(VT_ID, _id, 0);
970 }
971 bool KeyCompareLessThan(const Referrable *o) const {
972 return id() < o->id();
973 }
974 int KeyCompareWithValue(uint64_t val) const {
975 return static_cast<int>(id() > val) - static_cast<int>(id() < val);
976 }
977 bool Verify(flatbuffers::Verifier &verifier) const {
978 return VerifyTableStart(verifier) &&
979 VerifyField<uint64_t>(verifier, VT_ID) &&
980 verifier.EndTable();
981 }
982 ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
983 void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
984 static flatbuffers::Offset<Referrable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
985 };
986
987 struct ReferrableBuilder {
988 flatbuffers::FlatBufferBuilder &fbb_;
989 flatbuffers::uoffset_t start_;
990 void add_id(uint64_t id) {
991 fbb_.AddElement<uint64_t>(Referrable::VT_ID, id, 0);
992 }
993 explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
994 : fbb_(_fbb) {
995 start_ = fbb_.StartTable();
996 }
997 ReferrableBuilder &operator=(const ReferrableBuilder &);
998 flatbuffers::Offset<Referrable> Finish() {
999 const auto end = fbb_.EndTable(start_);
1000 auto o = flatbuffers::Offset<Referrable>(end);
1001 return o;
1002 }
1003 };
1004
1005 inline flatbuffers::Offset<Referrable> CreateReferrable(
1006 flatbuffers::FlatBufferBuilder &_fbb,
1007 uint64_t id = 0) {
1008 ReferrableBuilder builder_(_fbb);
1009 builder_.add_id(id);
1010 return builder_.Finish();
1011 }
1012
1013 flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1014
1015 struct MonsterT : public flatbuffers::NativeTable {
1016 typedef Monster TableType;
1017 flatbuffers::unique_ptr<Vec3> pos;
1018 int16_t mana;
1019 int16_t hp;
1020 std::string name;
1021 std::vector<uint8_t> inventory;
1022 Color color;
1023 AnyUnion test;
1024 std::vector<Test> test4;
1025 std::vector<std::string> testarrayofstring;
1026 std::vector<flatbuffers::unique_ptr<MonsterT>> testarrayoftables;
1027 flatbuffers::unique_ptr<MonsterT> enemy;
1028 std::vector<uint8_t> testnestedflatbuffer;
1029 flatbuffers::unique_ptr<StatT> testempty;
1030 bool testbool;
1031 int32_t testhashs32_fnv1;
1032 uint32_t testhashu32_fnv1;
1033 int64_t testhashs64_fnv1;
1034 uint64_t testhashu64_fnv1;
1035 int32_t testhashs32_fnv1a;
1036 Stat *testhashu32_fnv1a;
1037 int64_t testhashs64_fnv1a;
1038 uint64_t testhashu64_fnv1a;
1039 std::vector<bool> testarrayofbools;
1040 float testf;
1041 float testf2;
1042 float testf3;
1043 std::vector<std::string> testarrayofstring2;
1044 std::vector<Ability> testarrayofsortedstruct;
1045 std::vector<uint8_t> flex;
1046 std::vector<Test> test5;
1047 std::vector<int64_t> vector_of_longs;
1048 std::vector<double> vector_of_doubles;
1049 flatbuffers::unique_ptr<MyGame::InParentNamespaceT> parent_namespace_test;
1050 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_referrables;
1051 ReferrableT *single_weak_reference;
1052 std::vector<ReferrableT *> vector_of_weak_references;
1053 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_strong_referrables;
1054 ReferrableT *co_owning_reference;
1055 std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_co_owning_references;
1056 ReferrableT *non_owning_reference;
1057 std::vector<ReferrableT *> vector_of_non_owning_references;
1058 AnyUniqueAliasesUnion any_unique;
1059 AnyAmbiguousAliasesUnion any_ambiguous;
1060 std::vector<Color> vector_of_enums;
1061 MonsterT()
1062 : mana(150),
1063 hp(100),
1064 color(Color_Blue),
1065 testbool(false),
1066 testhashs32_fnv1(0),
1067 testhashu32_fnv1(0),
1068 testhashs64_fnv1(0),
1069 testhashu64_fnv1(0),
1070 testhashs32_fnv1a(0),
1071 testhashu32_fnv1a(nullptr),
1072 testhashs64_fnv1a(0),
1073 testhashu64_fnv1a(0),
1074 testf(3.14159f),
1075 testf2(3.0f),
1076 testf3(0.0f),
1077 single_weak_reference(nullptr),
1078 co_owning_reference(nullptr),
1079 non_owning_reference(nullptr) {
1080 }
1081 };
1082
1083 inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
1084 return
1085 (lhs.pos == rhs.pos) &&
1086 (lhs.mana == rhs.mana) &&
1087 (lhs.hp == rhs.hp) &&
1088 (lhs.name == rhs.name) &&
1089 (lhs.inventory == rhs.inventory) &&
1090 (lhs.color == rhs.color) &&
1091 (lhs.test == rhs.test) &&
1092 (lhs.test4 == rhs.test4) &&
1093 (lhs.testarrayofstring == rhs.testarrayofstring) &&
1094 (lhs.testarrayoftables == rhs.testarrayoftables) &&
1095 (lhs.enemy == rhs.enemy) &&
1096 (lhs.testnestedflatbuffer == rhs.testnestedflatbuffer) &&
1097 (lhs.testempty == rhs.testempty) &&
1098 (lhs.testbool == rhs.testbool) &&
1099 (lhs.testhashs32_fnv1 == rhs.testhashs32_fnv1) &&
1100 (lhs.testhashu32_fnv1 == rhs.testhashu32_fnv1) &&
1101 (lhs.testhashs64_fnv1 == rhs.testhashs64_fnv1) &&
1102 (lhs.testhashu64_fnv1 == rhs.testhashu64_fnv1) &&
1103 (lhs.testhashs32_fnv1a == rhs.testhashs32_fnv1a) &&
1104 (lhs.testhashu32_fnv1a == rhs.testhashu32_fnv1a) &&
1105 (lhs.testhashs64_fnv1a == rhs.testhashs64_fnv1a) &&
1106 (lhs.testhashu64_fnv1a == rhs.testhashu64_fnv1a) &&
1107 (lhs.testarrayofbools == rhs.testarrayofbools) &&
1108 (lhs.testf == rhs.testf) &&
1109 (lhs.testf2 == rhs.testf2) &&
1110 (lhs.testf3 == rhs.testf3) &&
1111 (lhs.testarrayofstring2 == rhs.testarrayofstring2) &&
1112 (lhs.testarrayofsortedstruct == rhs.testarrayofsortedstruct) &&
1113 (lhs.flex == rhs.flex) &&
1114 (lhs.test5 == rhs.test5) &&
1115 (lhs.vector_of_longs == rhs.vector_of_longs) &&
1116 (lhs.vector_of_doubles == rhs.vector_of_doubles) &&
1117 (lhs.parent_namespace_test == rhs.parent_namespace_test) &&
1118 (lhs.vector_of_referrables == rhs.vector_of_referrables) &&
1119 (lhs.single_weak_reference == rhs.single_weak_reference) &&
1120 (lhs.vector_of_weak_references == rhs.vector_of_weak_references) &&
1121 (lhs.vector_of_strong_referrables == rhs.vector_of_strong_referrables) &&
1122 (lhs.co_owning_reference == rhs.co_owning_reference) &&
1123 (lhs.vector_of_co_owning_references == rhs.vector_of_co_owning_references) &&
1124 (lhs.non_owning_reference == rhs.non_owning_reference) &&
1125 (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) &&
1126 (lhs.any_unique == rhs.any_unique) &&
1127 (lhs.any_ambiguous == rhs.any_ambiguous) &&
1128 (lhs.vector_of_enums == rhs.vector_of_enums);
1129 }
1130
1131 /// an example documentation comment: monster object
1132 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1133 typedef MonsterT NativeTableType;
1134 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1135 return MonsterTypeTable();
1136 }
1137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1138 VT_POS = 4,
1139 VT_MANA = 6,
1140 VT_HP = 8,
1141 VT_NAME = 10,
1142 VT_INVENTORY = 14,
1143 VT_COLOR = 16,
1144 VT_TEST_TYPE = 18,
1145 VT_TEST = 20,
1146 VT_TEST4 = 22,
1147 VT_TESTARRAYOFSTRING = 24,
1148 VT_TESTARRAYOFTABLES = 26,
1149 VT_ENEMY = 28,
1150 VT_TESTNESTEDFLATBUFFER = 30,
1151 VT_TESTEMPTY = 32,
1152 VT_TESTBOOL = 34,
1153 VT_TESTHASHS32_FNV1 = 36,
1154 VT_TESTHASHU32_FNV1 = 38,
1155 VT_TESTHASHS64_FNV1 = 40,
1156 VT_TESTHASHU64_FNV1 = 42,
1157 VT_TESTHASHS32_FNV1A = 44,
1158 VT_TESTHASHU32_FNV1A = 46,
1159 VT_TESTHASHS64_FNV1A = 48,
1160 VT_TESTHASHU64_FNV1A = 50,
1161 VT_TESTARRAYOFBOOLS = 52,
1162 VT_TESTF = 54,
1163 VT_TESTF2 = 56,
1164 VT_TESTF3 = 58,
1165 VT_TESTARRAYOFSTRING2 = 60,
1166 VT_TESTARRAYOFSORTEDSTRUCT = 62,
1167 VT_FLEX = 64,
1168 VT_TEST5 = 66,
1169 VT_VECTOR_OF_LONGS = 68,
1170 VT_VECTOR_OF_DOUBLES = 70,
1171 VT_PARENT_NAMESPACE_TEST = 72,
1172 VT_VECTOR_OF_REFERRABLES = 74,
1173 VT_SINGLE_WEAK_REFERENCE = 76,
1174 VT_VECTOR_OF_WEAK_REFERENCES = 78,
1175 VT_VECTOR_OF_STRONG_REFERRABLES = 80,
1176 VT_CO_OWNING_REFERENCE = 82,
1177 VT_VECTOR_OF_CO_OWNING_REFERENCES = 84,
1178 VT_NON_OWNING_REFERENCE = 86,
1179 VT_VECTOR_OF_NON_OWNING_REFERENCES = 88,
1180 VT_ANY_UNIQUE_TYPE = 90,
1181 VT_ANY_UNIQUE = 92,
1182 VT_ANY_AMBIGUOUS_TYPE = 94,
1183 VT_ANY_AMBIGUOUS = 96,
1184 VT_VECTOR_OF_ENUMS = 98
1185 };
1186 const Vec3 *pos() const {
1187 return GetStruct<const Vec3 *>(VT_POS);
1188 }
1189 Vec3 *mutable_pos() {
1190 return GetStruct<Vec3 *>(VT_POS);
1191 }
1192 int16_t mana() const {
1193 return GetField<int16_t>(VT_MANA, 150);
1194 }
1195 bool mutate_mana(int16_t _mana) {
1196 return SetField<int16_t>(VT_MANA, _mana, 150);
1197 }
1198 int16_t hp() const {
1199 return GetField<int16_t>(VT_HP, 100);
1200 }
1201 bool mutate_hp(int16_t _hp) {
1202 return SetField<int16_t>(VT_HP, _hp, 100);
1203 }
1204 const flatbuffers::String *name() const {
1205 return GetPointer<const flatbuffers::String *>(VT_NAME);
1206 }
1207 flatbuffers::String *mutable_name() {
1208 return GetPointer<flatbuffers::String *>(VT_NAME);
1209 }
1210 bool KeyCompareLessThan(const Monster *o) const {
1211 return *name() < *o->name();
1212 }
1213 int KeyCompareWithValue(const char *val) const {
1214 return strcmp(name()->c_str(), val);
1215 }
1216 const flatbuffers::Vector<uint8_t> *inventory() const {
1217 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1218 }
1219 flatbuffers::Vector<uint8_t> *mutable_inventory() {
1220 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
1221 }
1222 Color color() const {
1223 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 8));
1224 }
1225 bool mutate_color(Color _color) {
1226 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 8);
1227 }
1228 Any test_type() const {
1229 return static_cast<Any>(GetField<uint8_t>(VT_TEST_TYPE, 0));
1230 }
1231 bool mutate_test_type(Any _test_type) {
1232 return SetField<uint8_t>(VT_TEST_TYPE, static_cast<uint8_t>(_test_type), 0);
1233 }
1234 const void *test() const {
1235 return GetPointer<const void *>(VT_TEST);
1236 }
1237 template<typename T> const T *test_as() const;
1238 const Monster *test_as_Monster() const {
1239 return test_type() == Any_Monster ? static_cast<const Monster *>(test()) : nullptr;
1240 }
1241 const TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const {
1242 return test_type() == Any_TestSimpleTableWithEnum ? static_cast<const TestSimpleTableWithEnum *>(test()) : nullptr;
1243 }
1244 const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
1245 return test_type() == Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
1246 }
1247 void *mutable_test() {
1248 return GetPointer<void *>(VT_TEST);
1249 }
1250 const flatbuffers::Vector<const Test *> *test4() const {
1251 return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST4);
1252 }
1253 flatbuffers::Vector<const Test *> *mutable_test4() {
1254 return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST4);
1255 }
1256 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring() const {
1257 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1258 }
1259 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring() {
1260 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
1261 }
1262 /// an example documentation comment: this will end up in the generated code
1263 /// multiline too
1264 const flatbuffers::Vector<flatbuffers::Offset<Monster>> *testarrayoftables() const {
1265 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES);
1266 }
1267 flatbuffers::Vector<flatbuffers::Offset<Monster>> *mutable_testarrayoftables() {
1268 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES);
1269 }
1270 const Monster *enemy() const {
1271 return GetPointer<const Monster *>(VT_ENEMY);
1272 }
1273 Monster *mutable_enemy() {
1274 return GetPointer<Monster *>(VT_ENEMY);
1275 }
1276 const flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const {
1277 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1278 }
1279 flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() {
1280 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
1281 }
1282 const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const {
1283 return flatbuffers::GetRoot<MyGame::Example::Monster>(testnestedflatbuffer()->Data());
1284 }
1285 const Stat *testempty() const {
1286 return GetPointer<const Stat *>(VT_TESTEMPTY);
1287 }
1288 Stat *mutable_testempty() {
1289 return GetPointer<Stat *>(VT_TESTEMPTY);
1290 }
1291 bool testbool() const {
1292 return GetField<uint8_t>(VT_TESTBOOL, 0) != 0;
1293 }
1294 bool mutate_testbool(bool _testbool) {
1295 return SetField<uint8_t>(VT_TESTBOOL, static_cast<uint8_t>(_testbool), 0);
1296 }
1297 int32_t testhashs32_fnv1() const {
1298 return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0);
1299 }
1300 bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) {
1301 return SetField<int32_t>(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0);
1302 }
1303 uint32_t testhashu32_fnv1() const {
1304 return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0);
1305 }
1306 bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) {
1307 return SetField<uint32_t>(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0);
1308 }
1309 int64_t testhashs64_fnv1() const {
1310 return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0);
1311 }
1312 bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) {
1313 return SetField<int64_t>(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0);
1314 }
1315 uint64_t testhashu64_fnv1() const {
1316 return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0);
1317 }
1318 bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) {
1319 return SetField<uint64_t>(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0);
1320 }
1321 int32_t testhashs32_fnv1a() const {
1322 return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0);
1323 }
1324 bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) {
1325 return SetField<int32_t>(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0);
1326 }
1327 uint32_t testhashu32_fnv1a() const {
1328 return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0);
1329 }
1330 bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) {
1331 return SetField<uint32_t>(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0);
1332 }
1333 int64_t testhashs64_fnv1a() const {
1334 return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0);
1335 }
1336 bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) {
1337 return SetField<int64_t>(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0);
1338 }
1339 uint64_t testhashu64_fnv1a() const {
1340 return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0);
1341 }
1342 bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) {
1343 return SetField<uint64_t>(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0);
1344 }
1345 const flatbuffers::Vector<uint8_t> *testarrayofbools() const {
1346 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1347 }
1348 flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() {
1349 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
1350 }
1351 float testf() const {
1352 return GetField<float>(VT_TESTF, 3.14159f);
1353 }
1354 bool mutate_testf(float _testf) {
1355 return SetField<float>(VT_TESTF, _testf, 3.14159f);
1356 }
1357 float testf2() const {
1358 return GetField<float>(VT_TESTF2, 3.0f);
1359 }
1360 bool mutate_testf2(float _testf2) {
1361 return SetField<float>(VT_TESTF2, _testf2, 3.0f);
1362 }
1363 float testf3() const {
1364 return GetField<float>(VT_TESTF3, 0.0f);
1365 }
1366 bool mutate_testf3(float _testf3) {
1367 return SetField<float>(VT_TESTF3, _testf3, 0.0f);
1368 }
1369 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2() const {
1370 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1371 }
1372 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring2() {
1373 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
1374 }
1375 const flatbuffers::Vector<const Ability *> *testarrayofsortedstruct() const {
1376 return GetPointer<const flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1377 }
1378 flatbuffers::Vector<const Ability *> *mutable_testarrayofsortedstruct() {
1379 return GetPointer<flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
1380 }
1381 const flatbuffers::Vector<uint8_t> *flex() const {
1382 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1383 }
1384 flatbuffers::Vector<uint8_t> *mutable_flex() {
1385 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_FLEX);
1386 }
1387 flexbuffers::Reference flex_flexbuffer_root() const {
1388 return flexbuffers::GetRoot(flex()->Data(), flex()->size());
1389 }
1390 const flatbuffers::Vector<const Test *> *test5() const {
1391 return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST5);
1392 }
1393 flatbuffers::Vector<const Test *> *mutable_test5() {
1394 return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST5);
1395 }
1396 const flatbuffers::Vector<int64_t> *vector_of_longs() const {
1397 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1398 }
1399 flatbuffers::Vector<int64_t> *mutable_vector_of_longs() {
1400 return GetPointer<flatbuffers::Vector<int64_t> *>(VT_VECTOR_OF_LONGS);
1401 }
1402 const flatbuffers::Vector<double> *vector_of_doubles() const {
1403 return GetPointer<const flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1404 }
1405 flatbuffers::Vector<double> *mutable_vector_of_doubles() {
1406 return GetPointer<flatbuffers::Vector<double> *>(VT_VECTOR_OF_DOUBLES);
1407 }
1408 const MyGame::InParentNamespace *parent_namespace_test() const {
1409 return GetPointer<const MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1410 }
1411 MyGame::InParentNamespace *mutable_parent_namespace_test() {
1412 return GetPointer<MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
1413 }
1414 const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *vector_of_referrables() const {
1415 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1416 }
1417 flatbuffers::Vector<flatbuffers::Offset<Referrable>> *mutable_vector_of_referrables() {
1418 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
1419 }
1420 uint64_t single_weak_reference() const {
1421 return GetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, 0);
1422 }
1423 bool mutate_single_weak_reference(uint64_t _single_weak_reference) {
1424 return SetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0);
1425 }
1426 const flatbuffers::Vector<uint64_t> *vector_of_weak_references() const {
1427 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1428 }
1429 flatbuffers::Vector<uint64_t> *mutable_vector_of_weak_references() {
1430 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
1431 }
1432 const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *vector_of_strong_referrables() const {
1433 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1434 }
1435 flatbuffers::Vector<flatbuffers::Offset<Referrable>> *mutable_vector_of_strong_referrables() {
1436 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_STRONG_REFERRABLES);
1437 }
1438 uint64_t co_owning_reference() const {
1439 return GetField<uint64_t>(VT_CO_OWNING_REFERENCE, 0);
1440 }
1441 bool mutate_co_owning_reference(uint64_t _co_owning_reference) {
1442 return SetField<uint64_t>(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0);
1443 }
1444 const flatbuffers::Vector<uint64_t> *vector_of_co_owning_references() const {
1445 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1446 }
1447 flatbuffers::Vector<uint64_t> *mutable_vector_of_co_owning_references() {
1448 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_CO_OWNING_REFERENCES);
1449 }
1450 uint64_t non_owning_reference() const {
1451 return GetField<uint64_t>(VT_NON_OWNING_REFERENCE, 0);
1452 }
1453 bool mutate_non_owning_reference(uint64_t _non_owning_reference) {
1454 return SetField<uint64_t>(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0);
1455 }
1456 const flatbuffers::Vector<uint64_t> *vector_of_non_owning_references() const {
1457 return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1458 }
1459 flatbuffers::Vector<uint64_t> *mutable_vector_of_non_owning_references() {
1460 return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_NON_OWNING_REFERENCES);
1461 }
1462 AnyUniqueAliases any_unique_type() const {
1463 return static_cast<AnyUniqueAliases>(GetField<uint8_t>(VT_ANY_UNIQUE_TYPE, 0));
1464 }
1465 bool mutate_any_unique_type(AnyUniqueAliases _any_unique_type) {
1466 return SetField<uint8_t>(VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(_any_unique_type), 0);
1467 }
1468 const void *any_unique() const {
1469 return GetPointer<const void *>(VT_ANY_UNIQUE);
1470 }
1471 template<typename T> const T *any_unique_as() const;
1472 const Monster *any_unique_as_M() const {
1473 return any_unique_type() == AnyUniqueAliases_M ? static_cast<const Monster *>(any_unique()) : nullptr;
1474 }
1475 const TestSimpleTableWithEnum *any_unique_as_T() const {
1476 return any_unique_type() == AnyUniqueAliases_T ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr;
1477 }
1478 const MyGame::Example2::Monster *any_unique_as_M2() const {
1479 return any_unique_type() == AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
1480 }
1481 void *mutable_any_unique() {
1482 return GetPointer<void *>(VT_ANY_UNIQUE);
1483 }
1484 AnyAmbiguousAliases any_ambiguous_type() const {
1485 return static_cast<AnyAmbiguousAliases>(GetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, 0));
1486 }
1487 bool mutate_any_ambiguous_type(AnyAmbiguousAliases _any_ambiguous_type) {
1488 return SetField<uint8_t>(VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(_any_ambiguous_type), 0);
1489 }
1490 const void *any_ambiguous() const {
1491 return GetPointer<const void *>(VT_ANY_AMBIGUOUS);
1492 }
1493 const Monster *any_ambiguous_as_M1() const {
1494 return any_ambiguous_type() == AnyAmbiguousAliases_M1 ? static_cast<const Monster *>(any_ambiguous()) : nullptr;
1495 }
1496 const Monster *any_ambiguous_as_M2() const {
1497 return any_ambiguous_type() == AnyAmbiguousAliases_M2 ? static_cast<const Monster *>(any_ambiguous()) : nullptr;
1498 }
1499 const Monster *any_ambiguous_as_M3() const {
1500 return any_ambiguous_type() == AnyAmbiguousAliases_M3 ? static_cast<const Monster *>(any_ambiguous()) : nullptr;
1501 }
1502 void *mutable_any_ambiguous() {
1503 return GetPointer<void *>(VT_ANY_AMBIGUOUS);
1504 }
1505 const flatbuffers::Vector<int8_t> *vector_of_enums() const {
1506 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS);
1507 }
1508 flatbuffers::Vector<int8_t> *mutable_vector_of_enums() {
1509 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS);
1510 }
1511 bool Verify(flatbuffers::Verifier &verifier) const {
1512 return VerifyTableStart(verifier) &&
1513 VerifyField<Vec3>(verifier, VT_POS) &&
1514 VerifyField<int16_t>(verifier, VT_MANA) &&
1515 VerifyField<int16_t>(verifier, VT_HP) &&
1516 VerifyOffsetRequired(verifier, VT_NAME) &&
1517 verifier.VerifyString(name()) &&
1518 VerifyOffset(verifier, VT_INVENTORY) &&
1519 verifier.VerifyVector(inventory()) &&
1520 VerifyField<int8_t>(verifier, VT_COLOR) &&
1521 VerifyField<uint8_t>(verifier, VT_TEST_TYPE) &&
1522 VerifyOffset(verifier, VT_TEST) &&
1523 VerifyAny(verifier, test(), test_type()) &&
1524 VerifyOffset(verifier, VT_TEST4) &&
1525 verifier.VerifyVector(test4()) &&
1526 VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
1527 verifier.VerifyVector(testarrayofstring()) &&
1528 verifier.VerifyVectorOfStrings(testarrayofstring()) &&
1529 VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
1530 verifier.VerifyVector(testarrayoftables()) &&
1531 verifier.VerifyVectorOfTables(testarrayoftables()) &&
1532 VerifyOffset(verifier, VT_ENEMY) &&
1533 verifier.VerifyTable(enemy()) &&
1534 VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
1535 verifier.VerifyVector(testnestedflatbuffer()) &&
1536 VerifyOffset(verifier, VT_TESTEMPTY) &&
1537 verifier.VerifyTable(testempty()) &&
1538 VerifyField<uint8_t>(verifier, VT_TESTBOOL) &&
1539 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) &&
1540 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) &&
1541 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) &&
1542 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) &&
1543 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) &&
1544 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) &&
1545 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) &&
1546 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) &&
1547 VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
1548 verifier.VerifyVector(testarrayofbools()) &&
1549 VerifyField<float>(verifier, VT_TESTF) &&
1550 VerifyField<float>(verifier, VT_TESTF2) &&
1551 VerifyField<float>(verifier, VT_TESTF3) &&
1552 VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
1553 verifier.VerifyVector(testarrayofstring2()) &&
1554 verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
1555 VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
1556 verifier.VerifyVector(testarrayofsortedstruct()) &&
1557 VerifyOffset(verifier, VT_FLEX) &&
1558 verifier.VerifyVector(flex()) &&
1559 VerifyOffset(verifier, VT_TEST5) &&
1560 verifier.VerifyVector(test5()) &&
1561 VerifyOffset(verifier, VT_VECTOR_OF_LONGS) &&
1562 verifier.VerifyVector(vector_of_longs()) &&
1563 VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) &&
1564 verifier.VerifyVector(vector_of_doubles()) &&
1565 VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
1566 verifier.VerifyTable(parent_namespace_test()) &&
1567 VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
1568 verifier.VerifyVector(vector_of_referrables()) &&
1569 verifier.VerifyVectorOfTables(vector_of_referrables()) &&
1570 VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) &&
1571 VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
1572 verifier.VerifyVector(vector_of_weak_references()) &&
1573 VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
1574 verifier.VerifyVector(vector_of_strong_referrables()) &&
1575 verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
1576 VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) &&
1577 VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
1578 verifier.VerifyVector(vector_of_co_owning_references()) &&
1579 VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) &&
1580 VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
1581 verifier.VerifyVector(vector_of_non_owning_references()) &&
1582 VerifyField<uint8_t>(verifier, VT_ANY_UNIQUE_TYPE) &&
1583 VerifyOffset(verifier, VT_ANY_UNIQUE) &&
1584 VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) &&
1585 VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE) &&
1586 VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
1587 VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
1588 VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
1589 verifier.VerifyVector(vector_of_enums()) &&
1590 verifier.EndTable();
1591 }
1592 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1593 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1594 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1595 };
1596
1597 template<> inline const Monster *Monster::test_as<Monster>() const {
1598 return test_as_Monster();
1599 }
1600
1601 template<> inline const TestSimpleTableWithEnum *Monster::test_as<TestSimpleTableWithEnum>() const {
1602 return test_as_TestSimpleTableWithEnum();
1603 }
1604
1605 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
1606 return test_as_MyGame_Example2_Monster();
1607 }
1608
1609 template<> inline const Monster *Monster::any_unique_as<Monster>() const {
1610 return any_unique_as_M();
1611 }
1612
1613 template<> inline const TestSimpleTableWithEnum *Monster::any_unique_as<TestSimpleTableWithEnum>() const {
1614 return any_unique_as_T();
1615 }
1616
1617 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
1618 return any_unique_as_M2();
1619 }
1620
1621 struct MonsterBuilder {
1622 flatbuffers::FlatBufferBuilder &fbb_;
1623 flatbuffers::uoffset_t start_;
1624 void add_pos(const Vec3 *pos) {
1625 fbb_.AddStruct(Monster::VT_POS, pos);
1626 }
1627 void add_mana(int16_t mana) {
1628 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
1629 }
1630 void add_hp(int16_t hp) {
1631 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
1632 }
1633 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1634 fbb_.AddOffset(Monster::VT_NAME, name);
1635 }
1636 void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) {
1637 fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
1638 }
1639 void add_color(Color color) {
1640 fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 8);
1641 }
1642 void add_test_type(Any test_type) {
1643 fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0);
1644 }
1645 void add_test(flatbuffers::Offset<void> test) {
1646 fbb_.AddOffset(Monster::VT_TEST, test);
1647 }
1648 void add_test4(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4) {
1649 fbb_.AddOffset(Monster::VT_TEST4, test4);
1650 }
1651 void add_testarrayofstring(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring) {
1652 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring);
1653 }
1654 void add_testarrayoftables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables) {
1655 fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables);
1656 }
1657 void add_enemy(flatbuffers::Offset<Monster> enemy) {
1658 fbb_.AddOffset(Monster::VT_ENEMY, enemy);
1659 }
1660 void add_testnestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer) {
1661 fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer);
1662 }
1663 void add_testempty(flatbuffers::Offset<Stat> testempty) {
1664 fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty);
1665 }
1666 void add_testbool(bool testbool) {
1667 fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0);
1668 }
1669 void add_testhashs32_fnv1(int32_t testhashs32_fnv1) {
1670 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0);
1671 }
1672 void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) {
1673 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0);
1674 }
1675 void add_testhashs64_fnv1(int64_t testhashs64_fnv1) {
1676 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0);
1677 }
1678 void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) {
1679 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0);
1680 }
1681 void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) {
1682 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0);
1683 }
1684 void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) {
1685 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0);
1686 }
1687 void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) {
1688 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0);
1689 }
1690 void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) {
1691 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0);
1692 }
1693 void add_testarrayofbools(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools) {
1694 fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools);
1695 }
1696 void add_testf(float testf) {
1697 fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f);
1698 }
1699 void add_testf2(float testf2) {
1700 fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f);
1701 }
1702 void add_testf3(float testf3) {
1703 fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f);
1704 }
1705 void add_testarrayofstring2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2) {
1706 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2);
1707 }
1708 void add_testarrayofsortedstruct(flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct) {
1709 fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct);
1710 }
1711 void add_flex(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> flex) {
1712 fbb_.AddOffset(Monster::VT_FLEX, flex);
1713 }
1714 void add_test5(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test5) {
1715 fbb_.AddOffset(Monster::VT_TEST5, test5);
1716 }
1717 void add_vector_of_longs(flatbuffers::Offset<flatbuffers::Vector<int64_t>> vector_of_longs) {
1718 fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs);
1719 }
1720 void add_vector_of_doubles(flatbuffers::Offset<flatbuffers::Vector<double>> vector_of_doubles) {
1721 fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles);
1722 }
1723 void add_parent_namespace_test(flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test) {
1724 fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test);
1725 }
1726 void add_vector_of_referrables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables) {
1727 fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables);
1728 }
1729 void add_single_weak_reference(uint64_t single_weak_reference) {
1730 fbb_.AddElement<uint64_t>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0);
1731 }
1732 void add_vector_of_weak_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references) {
1733 fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references);
1734 }
1735 void add_vector_of_strong_referrables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_strong_referrables) {
1736 fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables);
1737 }
1738 void add_co_owning_reference(uint64_t co_owning_reference) {
1739 fbb_.AddElement<uint64_t>(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0);
1740 }
1741 void add_vector_of_co_owning_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_co_owning_references) {
1742 fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references);
1743 }
1744 void add_non_owning_reference(uint64_t non_owning_reference) {
1745 fbb_.AddElement<uint64_t>(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0);
1746 }
1747 void add_vector_of_non_owning_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_non_owning_references) {
1748 fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references);
1749 }
1750 void add_any_unique_type(AnyUniqueAliases any_unique_type) {
1751 fbb_.AddElement<uint8_t>(Monster::VT_ANY_UNIQUE_TYPE, static_cast<uint8_t>(any_unique_type), 0);
1752 }
1753 void add_any_unique(flatbuffers::Offset<void> any_unique) {
1754 fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique);
1755 }
1756 void add_any_ambiguous_type(AnyAmbiguousAliases any_ambiguous_type) {
1757 fbb_.AddElement<uint8_t>(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast<uint8_t>(any_ambiguous_type), 0);
1758 }
1759 void add_any_ambiguous(flatbuffers::Offset<void> any_ambiguous) {
1760 fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
1761 }
1762 void add_vector_of_enums(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums) {
1763 fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
1764 }
1765 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1766 : fbb_(_fbb) {
1767 start_ = fbb_.StartTable();
1768 }
1769 MonsterBuilder &operator=(const MonsterBuilder &);
1770 flatbuffers::Offset<Monster> Finish() {
1771 const auto end = fbb_.EndTable(start_);
1772 auto o = flatbuffers::Offset<Monster>(end);
1773 fbb_.Required(o, Monster::VT_NAME);
1774 return o;
1775 }
1776 };
1777
1778 inline flatbuffers::Offset<Monster> CreateMonster(
1779 flatbuffers::FlatBufferBuilder &_fbb,
1780 const Vec3 *pos = 0,
1781 int16_t mana = 150,
1782 int16_t hp = 100,
1783 flatbuffers::Offset<flatbuffers::String> name = 0,
1784 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
1785 Color color = Color_Blue,
1786 Any test_type = Any_NONE,
1787 flatbuffers::Offset<void> test = 0,
1788 flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4 = 0,
1789 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring = 0,
1790 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables = 0,
1791 flatbuffers::Offset<Monster> enemy = 0,
1792 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
1793 flatbuffers::Offset<Stat> testempty = 0,
1794 bool testbool = false,
1795 int32_t testhashs32_fnv1 = 0,
1796 uint32_t testhashu32_fnv1 = 0,
1797 int64_t testhashs64_fnv1 = 0,
1798 uint64_t testhashu64_fnv1 = 0,
1799 int32_t testhashs32_fnv1a = 0,
1800 uint32_t testhashu32_fnv1a = 0,
1801 int64_t testhashs64_fnv1a = 0,
1802 uint64_t testhashu64_fnv1a = 0,
1803 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools = 0,
1804 float testf = 3.14159f,
1805 float testf2 = 3.0f,
1806 float testf3 = 0.0f,
1807 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2 = 0,
1808 flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct = 0,
1809 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> flex = 0,
1810 flatbuffers::Offset<flatbuffers::Vector<const Test *>> test5 = 0,
1811 flatbuffers::Offset<flatbuffers::Vector<int64_t>> vector_of_longs = 0,
1812 flatbuffers::Offset<flatbuffers::Vector<double>> vector_of_doubles = 0,
1813 flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
1814 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables = 0,
1815 uint64_t single_weak_reference = 0,
1816 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0,
1817 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_strong_referrables = 0,
1818 uint64_t co_owning_reference = 0,
1819 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_co_owning_references = 0,
1820 uint64_t non_owning_reference = 0,
1821 flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_non_owning_references = 0,
1822 AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE,
1823 flatbuffers::Offset<void> any_unique = 0,
1824 AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE,
1825 flatbuffers::Offset<void> any_ambiguous = 0,
1826 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums = 0) {
1827 MonsterBuilder builder_(_fbb);
1828 builder_.add_non_owning_reference(non_owning_reference);
1829 builder_.add_co_owning_reference(co_owning_reference);
1830 builder_.add_single_weak_reference(single_weak_reference);
1831 builder_.add_testhashu64_fnv1a(testhashu64_fnv1a);
1832 builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
1833 builder_.add_testhashu64_fnv1(testhashu64_fnv1);
1834 builder_.add_testhashs64_fnv1(testhashs64_fnv1);
1835 builder_.add_vector_of_enums(vector_of_enums);
1836 builder_.add_any_ambiguous(any_ambiguous);
1837 builder_.add_any_unique(any_unique);
1838 builder_.add_vector_of_non_owning_references(vector_of_non_owning_references);
1839 builder_.add_vector_of_co_owning_references(vector_of_co_owning_references);
1840 builder_.add_vector_of_strong_referrables(vector_of_strong_referrables);
1841 builder_.add_vector_of_weak_references(vector_of_weak_references);
1842 builder_.add_vector_of_referrables(vector_of_referrables);
1843 builder_.add_parent_namespace_test(parent_namespace_test);
1844 builder_.add_vector_of_doubles(vector_of_doubles);
1845 builder_.add_vector_of_longs(vector_of_longs);
1846 builder_.add_test5(test5);
1847 builder_.add_flex(flex);
1848 builder_.add_testarrayofsortedstruct(testarrayofsortedstruct);
1849 builder_.add_testarrayofstring2(testarrayofstring2);
1850 builder_.add_testf3(testf3);
1851 builder_.add_testf2(testf2);
1852 builder_.add_testf(testf);
1853 builder_.add_testarrayofbools(testarrayofbools);
1854 builder_.add_testhashu32_fnv1a(testhashu32_fnv1a);
1855 builder_.add_testhashs32_fnv1a(testhashs32_fnv1a);
1856 builder_.add_testhashu32_fnv1(testhashu32_fnv1);
1857 builder_.add_testhashs32_fnv1(testhashs32_fnv1);
1858 builder_.add_testempty(testempty);
1859 builder_.add_testnestedflatbuffer(testnestedflatbuffer);
1860 builder_.add_enemy(enemy);
1861 builder_.add_testarrayoftables(testarrayoftables);
1862 builder_.add_testarrayofstring(testarrayofstring);
1863 builder_.add_test4(test4);
1864 builder_.add_test(test);
1865 builder_.add_inventory(inventory);
1866 builder_.add_name(name);
1867 builder_.add_pos(pos);
1868 builder_.add_hp(hp);
1869 builder_.add_mana(mana);
1870 builder_.add_any_ambiguous_type(any_ambiguous_type);
1871 builder_.add_any_unique_type(any_unique_type);
1872 builder_.add_testbool(testbool);
1873 builder_.add_test_type(test_type);
1874 builder_.add_color(color);
1875 return builder_.Finish();
1876 }
1877
1878 inline flatbuffers::Offset<Monster> CreateMonsterDirect(
1879 flatbuffers::FlatBufferBuilder &_fbb,
1880 const Vec3 *pos = 0,
1881 int16_t mana = 150,
1882 int16_t hp = 100,
1883 const char *name = nullptr,
1884 const std::vector<uint8_t> *inventory = nullptr,
1885 Color color = Color_Blue,
1886 Any test_type = Any_NONE,
1887 flatbuffers::Offset<void> test = 0,
1888 const std::vector<Test> *test4 = nullptr,
1889 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring = nullptr,
1890 const std::vector<flatbuffers::Offset<Monster>> *testarrayoftables = nullptr,
1891 flatbuffers::Offset<Monster> enemy = 0,
1892 const std::vector<uint8_t> *testnestedflatbuffer = nullptr,
1893 flatbuffers::Offset<Stat> testempty = 0,
1894 bool testbool = false,
1895 int32_t testhashs32_fnv1 = 0,
1896 uint32_t testhashu32_fnv1 = 0,
1897 int64_t testhashs64_fnv1 = 0,
1898 uint64_t testhashu64_fnv1 = 0,
1899 int32_t testhashs32_fnv1a = 0,
1900 uint32_t testhashu32_fnv1a = 0,
1901 int64_t testhashs64_fnv1a = 0,
1902 uint64_t testhashu64_fnv1a = 0,
1903 const std::vector<uint8_t> *testarrayofbools = nullptr,
1904 float testf = 3.14159f,
1905 float testf2 = 3.0f,
1906 float testf3 = 0.0f,
1907 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2 = nullptr,
1908 const std::vector<Ability> *testarrayofsortedstruct = nullptr,
1909 const std::vector<uint8_t> *flex = nullptr,
1910 const std::vector<Test> *test5 = nullptr,
1911 const std::vector<int64_t> *vector_of_longs = nullptr,
1912 const std::vector<double> *vector_of_doubles = nullptr,
1913 flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
1914 const std::vector<flatbuffers::Offset<Referrable>> *vector_of_referrables = nullptr,
1915 uint64_t single_weak_reference = 0,
1916 const std::vector<uint64_t> *vector_of_weak_references = nullptr,
1917 const std::vector<flatbuffers::Offset<Referrable>> *vector_of_strong_referrables = nullptr,
1918 uint64_t co_owning_reference = 0,
1919 const std::vector<uint64_t> *vector_of_co_owning_references = nullptr,
1920 uint64_t non_owning_reference = 0,
1921 const std::vector<uint64_t> *vector_of_non_owning_references = nullptr,
1922 AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE,
1923 flatbuffers::Offset<void> any_unique = 0,
1924 AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE,
1925 flatbuffers::Offset<void> any_ambiguous = 0,
1926 const std::vector<int8_t> *vector_of_enums = nullptr) {
1927 auto name__ = name ? _fbb.CreateString(name) : 0;
1928 auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
1929 auto test4__ = test4 ? _fbb.CreateVectorOfStructs<Test>(*test4) : 0;
1930 auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring) : 0;
1931 auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVector<flatbuffers::Offset<Monster>>(*testarrayoftables) : 0;
1932 auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0;
1933 auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0;
1934 auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring2) : 0;
1935 auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfStructs<Ability>(*testarrayofsortedstruct) : 0;
1936 auto flex__ = flex ? _fbb.CreateVector<uint8_t>(*flex) : 0;
1937 auto test5__ = test5 ? _fbb.CreateVectorOfStructs<Test>(*test5) : 0;
1938 auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector<int64_t>(*vector_of_longs) : 0;
1939 auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector<double>(*vector_of_doubles) : 0;
1940 auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVector<flatbuffers::Offset<Referrable>>(*vector_of_referrables) : 0;
1941 auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector<uint64_t>(*vector_of_weak_references) : 0;
1942 auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVector<flatbuffers::Offset<Referrable>>(*vector_of_strong_referrables) : 0;
1943 auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
1944 auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
1945 auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<int8_t>(*vector_of_enums) : 0;
1946 return MyGame::Example::CreateMonster(
1947 _fbb,
1948 pos,
1949 mana,
1950 hp,
1951 name__,
1952 inventory__,
1953 color,
1954 test_type,
1955 test,
1956 test4__,
1957 testarrayofstring__,
1958 testarrayoftables__,
1959 enemy,
1960 testnestedflatbuffer__,
1961 testempty,
1962 testbool,
1963 testhashs32_fnv1,
1964 testhashu32_fnv1,
1965 testhashs64_fnv1,
1966 testhashu64_fnv1,
1967 testhashs32_fnv1a,
1968 testhashu32_fnv1a,
1969 testhashs64_fnv1a,
1970 testhashu64_fnv1a,
1971 testarrayofbools__,
1972 testf,
1973 testf2,
1974 testf3,
1975 testarrayofstring2__,
1976 testarrayofsortedstruct__,
1977 flex__,
1978 test5__,
1979 vector_of_longs__,
1980 vector_of_doubles__,
1981 parent_namespace_test,
1982 vector_of_referrables__,
1983 single_weak_reference,
1984 vector_of_weak_references__,
1985 vector_of_strong_referrables__,
1986 co_owning_reference,
1987 vector_of_co_owning_references__,
1988 non_owning_reference,
1989 vector_of_non_owning_references__,
1990 any_unique_type,
1991 any_unique,
1992 any_ambiguous_type,
1993 any_ambiguous,
1994 vector_of_enums__);
1995 }
1996
1997 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1998
1999 struct TypeAliasesT : public flatbuffers::NativeTable {
2000 typedef TypeAliases TableType;
2001 int8_t i8;
2002 uint8_t u8;
2003 int16_t i16;
2004 uint16_t u16;
2005 int32_t i32;
2006 uint32_t u32;
2007 int64_t i64;
2008 uint64_t u64;
2009 float f32;
2010 double f64;
2011 std::vector<int8_t> v8;
2012 std::vector<double> vf64;
2013 TypeAliasesT()
2014 : i8(0),
2015 u8(0),
2016 i16(0),
2017 u16(0),
2018 i32(0),
2019 u32(0),
2020 i64(0),
2021 u64(0),
2022 f32(0.0f),
2023 f64(0.0) {
2024 }
2025 };
2026
2027 inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) {
2028 return
2029 (lhs.i8 == rhs.i8) &&
2030 (lhs.u8 == rhs.u8) &&
2031 (lhs.i16 == rhs.i16) &&
2032 (lhs.u16 == rhs.u16) &&
2033 (lhs.i32 == rhs.i32) &&
2034 (lhs.u32 == rhs.u32) &&
2035 (lhs.i64 == rhs.i64) &&
2036 (lhs.u64 == rhs.u64) &&
2037 (lhs.f32 == rhs.f32) &&
2038 (lhs.f64 == rhs.f64) &&
2039 (lhs.v8 == rhs.v8) &&
2040 (lhs.vf64 == rhs.vf64);
2041 }
2042
2043 struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2044 typedef TypeAliasesT NativeTableType;
2045 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2046 return TypeAliasesTypeTable();
2047 }
2048 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2049 VT_I8 = 4,
2050 VT_U8 = 6,
2051 VT_I16 = 8,
2052 VT_U16 = 10,
2053 VT_I32 = 12,
2054 VT_U32 = 14,
2055 VT_I64 = 16,
2056 VT_U64 = 18,
2057 VT_F32 = 20,
2058 VT_F64 = 22,
2059 VT_V8 = 24,
2060 VT_VF64 = 26
2061 };
2062 int8_t i8() const {
2063 return GetField<int8_t>(VT_I8, 0);
2064 }
2065 bool mutate_i8(int8_t _i8) {
2066 return SetField<int8_t>(VT_I8, _i8, 0);
2067 }
2068 uint8_t u8() const {
2069 return GetField<uint8_t>(VT_U8, 0);
2070 }
2071 bool mutate_u8(uint8_t _u8) {
2072 return SetField<uint8_t>(VT_U8, _u8, 0);
2073 }
2074 int16_t i16() const {
2075 return GetField<int16_t>(VT_I16, 0);
2076 }
2077 bool mutate_i16(int16_t _i16) {
2078 return SetField<int16_t>(VT_I16, _i16, 0);
2079 }
2080 uint16_t u16() const {
2081 return GetField<uint16_t>(VT_U16, 0);
2082 }
2083 bool mutate_u16(uint16_t _u16) {
2084 return SetField<uint16_t>(VT_U16, _u16, 0);
2085 }
2086 int32_t i32() const {
2087 return GetField<int32_t>(VT_I32, 0);
2088 }
2089 bool mutate_i32(int32_t _i32) {
2090 return SetField<int32_t>(VT_I32, _i32, 0);
2091 }
2092 uint32_t u32() const {
2093 return GetField<uint32_t>(VT_U32, 0);
2094 }
2095 bool mutate_u32(uint32_t _u32) {
2096 return SetField<uint32_t>(VT_U32, _u32, 0);
2097 }
2098 int64_t i64() const {
2099 return GetField<int64_t>(VT_I64, 0);
2100 }
2101 bool mutate_i64(int64_t _i64) {
2102 return SetField<int64_t>(VT_I64, _i64, 0);
2103 }
2104 uint64_t u64() const {
2105 return GetField<uint64_t>(VT_U64, 0);
2106 }
2107 bool mutate_u64(uint64_t _u64) {
2108 return SetField<uint64_t>(VT_U64, _u64, 0);
2109 }
2110 float f32() const {
2111 return GetField<float>(VT_F32, 0.0f);
2112 }
2113 bool mutate_f32(float _f32) {
2114 return SetField<float>(VT_F32, _f32, 0.0f);
2115 }
2116 double f64() const {
2117 return GetField<double>(VT_F64, 0.0);
2118 }
2119 bool mutate_f64(double _f64) {
2120 return SetField<double>(VT_F64, _f64, 0.0);
2121 }
2122 const flatbuffers::Vector<int8_t> *v8() const {
2123 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_V8);
2124 }
2125 flatbuffers::Vector<int8_t> *mutable_v8() {
2126 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_V8);
2127 }
2128 const flatbuffers::Vector<double> *vf64() const {
2129 return GetPointer<const flatbuffers::Vector<double> *>(VT_VF64);
2130 }
2131 flatbuffers::Vector<double> *mutable_vf64() {
2132 return GetPointer<flatbuffers::Vector<double> *>(VT_VF64);
2133 }
2134 bool Verify(flatbuffers::Verifier &verifier) const {
2135 return VerifyTableStart(verifier) &&
2136 VerifyField<int8_t>(verifier, VT_I8) &&
2137 VerifyField<uint8_t>(verifier, VT_U8) &&
2138 VerifyField<int16_t>(verifier, VT_I16) &&
2139 VerifyField<uint16_t>(verifier, VT_U16) &&
2140 VerifyField<int32_t>(verifier, VT_I32) &&
2141 VerifyField<uint32_t>(verifier, VT_U32) &&
2142 VerifyField<int64_t>(verifier, VT_I64) &&
2143 VerifyField<uint64_t>(verifier, VT_U64) &&
2144 VerifyField<float>(verifier, VT_F32) &&
2145 VerifyField<double>(verifier, VT_F64) &&
2146 VerifyOffset(verifier, VT_V8) &&
2147 verifier.VerifyVector(v8()) &&
2148 VerifyOffset(verifier, VT_VF64) &&
2149 verifier.VerifyVector(vf64()) &&
2150 verifier.EndTable();
2151 }
2152 TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2153 void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2154 static flatbuffers::Offset<TypeAliases> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2155 };
2156
2157 struct TypeAliasesBuilder {
2158 flatbuffers::FlatBufferBuilder &fbb_;
2159 flatbuffers::uoffset_t start_;
2160 void add_i8(int8_t i8) {
2161 fbb_.AddElement<int8_t>(TypeAliases::VT_I8, i8, 0);
2162 }
2163 void add_u8(uint8_t u8) {
2164 fbb_.AddElement<uint8_t>(TypeAliases::VT_U8, u8, 0);
2165 }
2166 void add_i16(int16_t i16) {
2167 fbb_.AddElement<int16_t>(TypeAliases::VT_I16, i16, 0);
2168 }
2169 void add_u16(uint16_t u16) {
2170 fbb_.AddElement<uint16_t>(TypeAliases::VT_U16, u16, 0);
2171 }
2172 void add_i32(int32_t i32) {
2173 fbb_.AddElement<int32_t>(TypeAliases::VT_I32, i32, 0);
2174 }
2175 void add_u32(uint32_t u32) {
2176 fbb_.AddElement<uint32_t>(TypeAliases::VT_U32, u32, 0);
2177 }
2178 void add_i64(int64_t i64) {
2179 fbb_.AddElement<int64_t>(TypeAliases::VT_I64, i64, 0);
2180 }
2181 void add_u64(uint64_t u64) {
2182 fbb_.AddElement<uint64_t>(TypeAliases::VT_U64, u64, 0);
2183 }
2184 void add_f32(float f32) {
2185 fbb_.AddElement<float>(TypeAliases::VT_F32, f32, 0.0f);
2186 }
2187 void add_f64(double f64) {
2188 fbb_.AddElement<double>(TypeAliases::VT_F64, f64, 0.0);
2189 }
2190 void add_v8(flatbuffers::Offset<flatbuffers::Vector<int8_t>> v8) {
2191 fbb_.AddOffset(TypeAliases::VT_V8, v8);
2192 }
2193 void add_vf64(flatbuffers::Offset<flatbuffers::Vector<double>> vf64) {
2194 fbb_.AddOffset(TypeAliases::VT_VF64, vf64);
2195 }
2196 explicit TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2197 : fbb_(_fbb) {
2198 start_ = fbb_.StartTable();
2199 }
2200 TypeAliasesBuilder &operator=(const TypeAliasesBuilder &);
2201 flatbuffers::Offset<TypeAliases> Finish() {
2202 const auto end = fbb_.EndTable(start_);
2203 auto o = flatbuffers::Offset<TypeAliases>(end);
2204 return o;
2205 }
2206 };
2207
2208 inline flatbuffers::Offset<TypeAliases> CreateTypeAliases(
2209 flatbuffers::FlatBufferBuilder &_fbb,
2210 int8_t i8 = 0,
2211 uint8_t u8 = 0,
2212 int16_t i16 = 0,
2213 uint16_t u16 = 0,
2214 int32_t i32 = 0,
2215 uint32_t u32 = 0,
2216 int64_t i64 = 0,
2217 uint64_t u64 = 0,
2218 float f32 = 0.0f,
2219 double f64 = 0.0,
2220 flatbuffers::Offset<flatbuffers::Vector<int8_t>> v8 = 0,
2221 flatbuffers::Offset<flatbuffers::Vector<double>> vf64 = 0) {
2222 TypeAliasesBuilder builder_(_fbb);
2223 builder_.add_f64(f64);
2224 builder_.add_u64(u64);
2225 builder_.add_i64(i64);
2226 builder_.add_vf64(vf64);
2227 builder_.add_v8(v8);
2228 builder_.add_f32(f32);
2229 builder_.add_u32(u32);
2230 builder_.add_i32(i32);
2231 builder_.add_u16(u16);
2232 builder_.add_i16(i16);
2233 builder_.add_u8(u8);
2234 builder_.add_i8(i8);
2235 return builder_.Finish();
2236 }
2237
2238 inline flatbuffers::Offset<TypeAliases> CreateTypeAliasesDirect(
2239 flatbuffers::FlatBufferBuilder &_fbb,
2240 int8_t i8 = 0,
2241 uint8_t u8 = 0,
2242 int16_t i16 = 0,
2243 uint16_t u16 = 0,
2244 int32_t i32 = 0,
2245 uint32_t u32 = 0,
2246 int64_t i64 = 0,
2247 uint64_t u64 = 0,
2248 float f32 = 0.0f,
2249 double f64 = 0.0,
2250 const std::vector<int8_t> *v8 = nullptr,
2251 const std::vector<double> *vf64 = nullptr) {
2252 auto v8__ = v8 ? _fbb.CreateVector<int8_t>(*v8) : 0;
2253 auto vf64__ = vf64 ? _fbb.CreateVector<double>(*vf64) : 0;
2254 return MyGame::Example::CreateTypeAliases(
2255 _fbb,
2256 i8,
2257 u8,
2258 i16,
2259 u16,
2260 i32,
2261 u32,
2262 i64,
2263 u64,
2264 f32,
2265 f64,
2266 v8__,
2267 vf64__);
2268 }
2269
2270 flatbuffers::Offset<TypeAliases> CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2271
2272 } // namespace Example
2273
2274 inline InParentNamespaceT *InParentNamespace::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2275 auto _o = new InParentNamespaceT();
2276 UnPackTo(_o, _resolver);
2277 return _o;
2278 }
2279
2280 inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2281 (void)_o;
2282 (void)_resolver;
2283 }
2284
2285 inline flatbuffers::Offset<InParentNamespace> InParentNamespace::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2286 return CreateInParentNamespace(_fbb, _o, _rehasher);
2287 }
2288
2289 inline flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2290 (void)_rehasher;
2291 (void)_o;
2292 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2293 return MyGame::CreateInParentNamespace(
2294 _fbb);
2295 }
2296
2297 namespace Example2 {
2298
2299 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2300 auto _o = new MonsterT();
2301 UnPackTo(_o, _resolver);
2302 return _o;
2303 }
2304
2305 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2306 (void)_o;
2307 (void)_resolver;
2308 }
2309
2310 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2311 return CreateMonster(_fbb, _o, _rehasher);
2312 }
2313
2314 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2315 (void)_rehasher;
2316 (void)_o;
2317 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2318 return MyGame::Example2::CreateMonster(
2319 _fbb);
2320 }
2321
2322 } // namespace Example2
2323
2324 namespace Example {
2325
2326 inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2327 auto _o = new TestSimpleTableWithEnumT();
2328 UnPackTo(_o, _resolver);
2329 return _o;
2330 }
2331
2332 inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2333 (void)_o;
2334 (void)_resolver;
2335 { auto _e = color(); _o->color = _e; };
2336 }
2337
2338 inline flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2339 return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher);
2340 }
2341
2342 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2343 (void)_rehasher;
2344 (void)_o;
2345 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2346 auto _color = _o->color;
2347 return MyGame::Example::CreateTestSimpleTableWithEnum(
2348 _fbb,
2349 _color);
2350 }
2351
2352 inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2353 auto _o = new StatT();
2354 UnPackTo(_o, _resolver);
2355 return _o;
2356 }
2357
2358 inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2359 (void)_o;
2360 (void)_resolver;
2361 { auto _e = id(); if (_e) _o->id = _e->str(); };
2362 { auto _e = val(); _o->val = _e; };
2363 { auto _e = count(); _o->count = _e; };
2364 }
2365
2366 inline flatbuffers::Offset<Stat> Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2367 return CreateStat(_fbb, _o, _rehasher);
2368 }
2369
2370 inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2371 (void)_rehasher;
2372 (void)_o;
2373 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2374 auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id);
2375 auto _val = _o->val;
2376 auto _count = _o->count;
2377 return MyGame::Example::CreateStat(
2378 _fbb,
2379 _id,
2380 _val,
2381 _count);
2382 }
2383
2384 inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2385 auto _o = new ReferrableT();
2386 UnPackTo(_o, _resolver);
2387 return _o;
2388 }
2389
2390 inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2391 (void)_o;
2392 (void)_resolver;
2393 { auto _e = id(); _o->id = _e; };
2394 }
2395
2396 inline flatbuffers::Offset<Referrable> Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2397 return CreateReferrable(_fbb, _o, _rehasher);
2398 }
2399
2400 inline flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2401 (void)_rehasher;
2402 (void)_o;
2403 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2404 auto _id = _o->id;
2405 return MyGame::Example::CreateReferrable(
2406 _fbb,
2407 _id);
2408 }
2409
2410 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2411 auto _o = new MonsterT();
2412 UnPackTo(_o, _resolver);
2413 return _o;
2414 }
2415
2416 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2417 (void)_o;
2418 (void)_resolver;
2419 { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<Vec3>(new Vec3(*_e)); };
2420 { auto _e = mana(); _o->mana = _e; };
2421 { auto _e = hp(); _o->hp = _e; };
2422 { auto _e = name(); if (_e) _o->name = _e->str(); };
2423 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory[_i] = _e->Get(_i); } } };
2424 { auto _e = color(); _o->color = _e; };
2425 { auto _e = test_type(); _o->test.type = _e; };
2426 { auto _e = test(); if (_e) _o->test.value = AnyUnion::UnPack(_e, test_type(), _resolver); };
2427 { 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); } } };
2428 { 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(); } } };
2429 { auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = flatbuffers::unique_ptr<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } };
2430 { auto _e = enemy(); if (_e) _o->enemy = flatbuffers::unique_ptr<MonsterT>(_e->UnPack(_resolver)); };
2431 { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer[_i] = _e->Get(_i); } } };
2432 { auto _e = testempty(); if (_e) _o->testempty = flatbuffers::unique_ptr<StatT>(_e->UnPack(_resolver)); };
2433 { auto _e = testbool(); _o->testbool = _e; };
2434 { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; };
2435 { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; };
2436 { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; };
2437 { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; };
2438 { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; };
2439 { auto _e = testhashu32_fnv1a(); //scalar resolver, naked
2440 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->testhashu32_fnv1a), static_cast<flatbuffers::hash_value_t>(_e)); else _o->testhashu32_fnv1a = nullptr; };
2441 { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; };
2442 { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; };
2443 { 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; } } };
2444 { auto _e = testf(); _o->testf = _e; };
2445 { auto _e = testf2(); _o->testf2 = _e; };
2446 { auto _e = testf3(); _o->testf3 = _e; };
2447 { 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(); } } };
2448 { 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); } } };
2449 { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->flex[_i] = _e->Get(_i); } } };
2450 { 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); } } };
2451 { 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); } } };
2452 { 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); } } };
2453 { auto _e = parent_namespace_test(); if (_e) _o->parent_namespace_test = flatbuffers::unique_ptr<MyGame::InParentNamespaceT>(_e->UnPack(_resolver)); };
2454 { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } };
2455 { auto _e = single_weak_reference(); //scalar resolver, naked
2456 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->single_weak_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->single_weak_reference = nullptr; };
2457 { 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
2458 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; } } };
2459 { 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++) { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } };
2460 { auto _e = co_owning_reference(); //scalar resolver, naked
2461 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->co_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->co_owning_reference = nullptr; };
2462 { 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
2463 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 */; } } };
2464 { auto _e = non_owning_reference(); //scalar resolver, naked
2465 if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->non_owning_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->non_owning_reference = nullptr; };
2466 { 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
2467 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; } } };
2468 { auto _e = any_unique_type(); _o->any_unique.type = _e; };
2469 { auto _e = any_unique(); if (_e) _o->any_unique.value = AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); };
2470 { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; };
2471 { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); };
2472 { 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<Color>(_e->Get(_i)); } } };
2473 }
2474
2475 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2476 return CreateMonster(_fbb, _o, _rehasher);
2477 }
2478
2479 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2480 (void)_rehasher;
2481 (void)_o;
2482 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2483 auto _pos = _o->pos ? _o->pos.get() : 0;
2484 auto _mana = _o->mana;
2485 auto _hp = _o->hp;
2486 auto _name = _fbb.CreateString(_o->name);
2487 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
2488 auto _color = _o->color;
2489 auto _test_type = _o->test.type;
2490 auto _test = _o->test.Pack(_fbb);
2491 auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
2492 auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
2493 auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<flatbuffers::Offset<Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
2494 auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
2495 auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
2496 auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
2497 auto _testbool = _o->testbool;
2498 auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
2499 auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
2500 auto _testhashs64_fnv1 = _o->testhashs64_fnv1;
2501 auto _testhashu64_fnv1 = _o->testhashu64_fnv1;
2502 auto _testhashs32_fnv1a = _o->testhashs32_fnv1a;
2503 auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0;
2504 auto _testhashs64_fnv1a = _o->testhashs64_fnv1a;
2505 auto _testhashu64_fnv1a = _o->testhashu64_fnv1a;
2506 auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0;
2507 auto _testf = _o->testf;
2508 auto _testf2 = _o->testf2;
2509 auto _testf3 = _o->testf3;
2510 auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0;
2511 auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0;
2512 auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0;
2513 auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0;
2514 auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
2515 auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
2516 auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
2517 auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<flatbuffers::Offset<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;
2518 auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
2519 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;
2520 auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<flatbuffers::Offset<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;
2521 auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0;
2522 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;
2523 auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0;
2524 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;
2525 auto _any_unique_type = _o->any_unique.type;
2526 auto _any_unique = _o->any_unique.Pack(_fbb);
2527 auto _any_ambiguous_type = _o->any_ambiguous.type;
2528 auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
2529 auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast<int8_t>(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0;
2530 return MyGame::Example::CreateMonster(
2531 _fbb,
2532 _pos,
2533 _mana,
2534 _hp,
2535 _name,
2536 _inventory,
2537 _color,
2538 _test_type,
2539 _test,
2540 _test4,
2541 _testarrayofstring,
2542 _testarrayoftables,
2543 _enemy,
2544 _testnestedflatbuffer,
2545 _testempty,
2546 _testbool,
2547 _testhashs32_fnv1,
2548 _testhashu32_fnv1,
2549 _testhashs64_fnv1,
2550 _testhashu64_fnv1,
2551 _testhashs32_fnv1a,
2552 _testhashu32_fnv1a,
2553 _testhashs64_fnv1a,
2554 _testhashu64_fnv1a,
2555 _testarrayofbools,
2556 _testf,
2557 _testf2,
2558 _testf3,
2559 _testarrayofstring2,
2560 _testarrayofsortedstruct,
2561 _flex,
2562 _test5,
2563 _vector_of_longs,
2564 _vector_of_doubles,
2565 _parent_namespace_test,
2566 _vector_of_referrables,
2567 _single_weak_reference,
2568 _vector_of_weak_references,
2569 _vector_of_strong_referrables,
2570 _co_owning_reference,
2571 _vector_of_co_owning_references,
2572 _non_owning_reference,
2573 _vector_of_non_owning_references,
2574 _any_unique_type,
2575 _any_unique,
2576 _any_ambiguous_type,
2577 _any_ambiguous,
2578 _vector_of_enums);
2579 }
2580
2581 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2582 auto _o = new TypeAliasesT();
2583 UnPackTo(_o, _resolver);
2584 return _o;
2585 }
2586
2587 inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2588 (void)_o;
2589 (void)_resolver;
2590 { auto _e = i8(); _o->i8 = _e; };
2591 { auto _e = u8(); _o->u8 = _e; };
2592 { auto _e = i16(); _o->i16 = _e; };
2593 { auto _e = u16(); _o->u16 = _e; };
2594 { auto _e = i32(); _o->i32 = _e; };
2595 { auto _e = u32(); _o->u32 = _e; };
2596 { auto _e = i64(); _o->i64 = _e; };
2597 { auto _e = u64(); _o->u64 = _e; };
2598 { auto _e = f32(); _o->f32 = _e; };
2599 { auto _e = f64(); _o->f64 = _e; };
2600 { auto _e = v8(); if (_e) { _o->v8.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->v8[_i] = _e->Get(_i); } } };
2601 { 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); } } };
2602 }
2603
2604 inline flatbuffers::Offset<TypeAliases> TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2605 return CreateTypeAliases(_fbb, _o, _rehasher);
2606 }
2607
2608 inline flatbuffers::Offset<TypeAliases> CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2609 (void)_rehasher;
2610 (void)_o;
2611 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2612 auto _i8 = _o->i8;
2613 auto _u8 = _o->u8;
2614 auto _i16 = _o->i16;
2615 auto _u16 = _o->u16;
2616 auto _i32 = _o->i32;
2617 auto _u32 = _o->u32;
2618 auto _i64 = _o->i64;
2619 auto _u64 = _o->u64;
2620 auto _f32 = _o->f32;
2621 auto _f64 = _o->f64;
2622 auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0;
2623 auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0;
2624 return MyGame::Example::CreateTypeAliases(
2625 _fbb,
2626 _i8,
2627 _u8,
2628 _i16,
2629 _u16,
2630 _i32,
2631 _u32,
2632 _i64,
2633 _u64,
2634 _f32,
2635 _f64,
2636 _v8,
2637 _vf64);
2638 }
2639
2640 inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) {
2641 switch (type) {
2642 case Any_NONE: {
2643 return true;
2644 }
2645 case Any_Monster: {
2646 auto ptr = reinterpret_cast<const Monster *>(obj);
2647 return verifier.VerifyTable(ptr);
2648 }
2649 case Any_TestSimpleTableWithEnum: {
2650 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
2651 return verifier.VerifyTable(ptr);
2652 }
2653 case Any_MyGame_Example2_Monster: {
2654 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
2655 return verifier.VerifyTable(ptr);
2656 }
2657 default: return false;
2658 }
2659 }
2660
2661 inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2662 if (!values || !types) return !values && !types;
2663 if (values->size() != types->size()) return false;
2664 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2665 if (!VerifyAny(
2666 verifier, values->Get(i), types->GetEnum<Any>(i))) {
2667 return false;
2668 }
2669 }
2670 return true;
2671 }
2672
2673 inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) {
2674 switch (type) {
2675 case Any_Monster: {
2676 auto ptr = reinterpret_cast<const Monster *>(obj);
2677 return ptr->UnPack(resolver);
2678 }
2679 case Any_TestSimpleTableWithEnum: {
2680 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
2681 return ptr->UnPack(resolver);
2682 }
2683 case Any_MyGame_Example2_Monster: {
2684 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
2685 return ptr->UnPack(resolver);
2686 }
2687 default: return nullptr;
2688 }
2689 }
2690
2691 inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
2692 switch (type) {
2693 case Any_Monster: {
2694 auto ptr = reinterpret_cast<const MonsterT *>(value);
2695 return CreateMonster(_fbb, ptr, _rehasher).Union();
2696 }
2697 case Any_TestSimpleTableWithEnum: {
2698 auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
2699 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
2700 }
2701 case Any_MyGame_Example2_Monster: {
2702 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
2703 return CreateMonster(_fbb, ptr, _rehasher).Union();
2704 }
2705 default: return 0;
2706 }
2707 }
2708
2709 inline AnyUnion::AnyUnion(const AnyUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
2710 switch (type) {
2711 case Any_Monster: {
2712 FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
2713 break;
2714 }
2715 case Any_TestSimpleTableWithEnum: {
2716 value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value));
2717 break;
2718 }
2719 case Any_MyGame_Example2_Monster: {
2720 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
2721 break;
2722 }
2723 default:
2724 break;
2725 }
2726 }
2727
2728 inline void AnyUnion::Reset() {
2729 switch (type) {
2730 case Any_Monster: {
2731 auto ptr = reinterpret_cast<MonsterT *>(value);
2732 delete ptr;
2733 break;
2734 }
2735 case Any_TestSimpleTableWithEnum: {
2736 auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
2737 delete ptr;
2738 break;
2739 }
2740 case Any_MyGame_Example2_Monster: {
2741 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
2742 delete ptr;
2743 break;
2744 }
2745 default: break;
2746 }
2747 value = nullptr;
2748 type = Any_NONE;
2749 }
2750
2751 inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
2752 switch (type) {
2753 case AnyUniqueAliases_NONE: {
2754 return true;
2755 }
2756 case AnyUniqueAliases_M: {
2757 auto ptr = reinterpret_cast<const Monster *>(obj);
2758 return verifier.VerifyTable(ptr);
2759 }
2760 case AnyUniqueAliases_T: {
2761 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
2762 return verifier.VerifyTable(ptr);
2763 }
2764 case AnyUniqueAliases_M2: {
2765 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
2766 return verifier.VerifyTable(ptr);
2767 }
2768 default: return false;
2769 }
2770 }
2771
2772 inline bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2773 if (!values || !types) return !values && !types;
2774 if (values->size() != types->size()) return false;
2775 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2776 if (!VerifyAnyUniqueAliases(
2777 verifier, values->Get(i), types->GetEnum<AnyUniqueAliases>(i))) {
2778 return false;
2779 }
2780 }
2781 return true;
2782 }
2783
2784 inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver) {
2785 switch (type) {
2786 case AnyUniqueAliases_M: {
2787 auto ptr = reinterpret_cast<const Monster *>(obj);
2788 return ptr->UnPack(resolver);
2789 }
2790 case AnyUniqueAliases_T: {
2791 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
2792 return ptr->UnPack(resolver);
2793 }
2794 case AnyUniqueAliases_M2: {
2795 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
2796 return ptr->UnPack(resolver);
2797 }
2798 default: return nullptr;
2799 }
2800 }
2801
2802 inline flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
2803 switch (type) {
2804 case AnyUniqueAliases_M: {
2805 auto ptr = reinterpret_cast<const MonsterT *>(value);
2806 return CreateMonster(_fbb, ptr, _rehasher).Union();
2807 }
2808 case AnyUniqueAliases_T: {
2809 auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
2810 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
2811 }
2812 case AnyUniqueAliases_M2: {
2813 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
2814 return CreateMonster(_fbb, ptr, _rehasher).Union();
2815 }
2816 default: return 0;
2817 }
2818 }
2819
2820 inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
2821 switch (type) {
2822 case AnyUniqueAliases_M: {
2823 FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
2824 break;
2825 }
2826 case AnyUniqueAliases_T: {
2827 value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value));
2828 break;
2829 }
2830 case AnyUniqueAliases_M2: {
2831 value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
2832 break;
2833 }
2834 default:
2835 break;
2836 }
2837 }
2838
2839 inline void AnyUniqueAliasesUnion::Reset() {
2840 switch (type) {
2841 case AnyUniqueAliases_M: {
2842 auto ptr = reinterpret_cast<MonsterT *>(value);
2843 delete ptr;
2844 break;
2845 }
2846 case AnyUniqueAliases_T: {
2847 auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
2848 delete ptr;
2849 break;
2850 }
2851 case AnyUniqueAliases_M2: {
2852 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
2853 delete ptr;
2854 break;
2855 }
2856 default: break;
2857 }
2858 value = nullptr;
2859 type = AnyUniqueAliases_NONE;
2860 }
2861
2862 inline bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
2863 switch (type) {
2864 case AnyAmbiguousAliases_NONE: {
2865 return true;
2866 }
2867 case AnyAmbiguousAliases_M1: {
2868 auto ptr = reinterpret_cast<const Monster *>(obj);
2869 return verifier.VerifyTable(ptr);
2870 }
2871 case AnyAmbiguousAliases_M2: {
2872 auto ptr = reinterpret_cast<const Monster *>(obj);
2873 return verifier.VerifyTable(ptr);
2874 }
2875 case AnyAmbiguousAliases_M3: {
2876 auto ptr = reinterpret_cast<const Monster *>(obj);
2877 return verifier.VerifyTable(ptr);
2878 }
2879 default: return false;
2880 }
2881 }
2882
2883 inline bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2884 if (!values || !types) return !values && !types;
2885 if (values->size() != types->size()) return false;
2886 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2887 if (!VerifyAnyAmbiguousAliases(
2888 verifier, values->Get(i), types->GetEnum<AnyAmbiguousAliases>(i))) {
2889 return false;
2890 }
2891 }
2892 return true;
2893 }
2894
2895 inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver) {
2896 switch (type) {
2897 case AnyAmbiguousAliases_M1: {
2898 auto ptr = reinterpret_cast<const Monster *>(obj);
2899 return ptr->UnPack(resolver);
2900 }
2901 case AnyAmbiguousAliases_M2: {
2902 auto ptr = reinterpret_cast<const Monster *>(obj);
2903 return ptr->UnPack(resolver);
2904 }
2905 case AnyAmbiguousAliases_M3: {
2906 auto ptr = reinterpret_cast<const Monster *>(obj);
2907 return ptr->UnPack(resolver);
2908 }
2909 default: return nullptr;
2910 }
2911 }
2912
2913 inline flatbuffers::Offset<void> AnyAmbiguousAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
2914 switch (type) {
2915 case AnyAmbiguousAliases_M1: {
2916 auto ptr = reinterpret_cast<const MonsterT *>(value);
2917 return CreateMonster(_fbb, ptr, _rehasher).Union();
2918 }
2919 case AnyAmbiguousAliases_M2: {
2920 auto ptr = reinterpret_cast<const MonsterT *>(value);
2921 return CreateMonster(_fbb, ptr, _rehasher).Union();
2922 }
2923 case AnyAmbiguousAliases_M3: {
2924 auto ptr = reinterpret_cast<const MonsterT *>(value);
2925 return CreateMonster(_fbb, ptr, _rehasher).Union();
2926 }
2927 default: return 0;
2928 }
2929 }
2930
2931 inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
2932 switch (type) {
2933 case AnyAmbiguousAliases_M1: {
2934 FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
2935 break;
2936 }
2937 case AnyAmbiguousAliases_M2: {
2938 FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
2939 break;
2940 }
2941 case AnyAmbiguousAliases_M3: {
2942 FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
2943 break;
2944 }
2945 default:
2946 break;
2947 }
2948 }
2949
2950 inline void AnyAmbiguousAliasesUnion::Reset() {
2951 switch (type) {
2952 case AnyAmbiguousAliases_M1: {
2953 auto ptr = reinterpret_cast<MonsterT *>(value);
2954 delete ptr;
2955 break;
2956 }
2957 case AnyAmbiguousAliases_M2: {
2958 auto ptr = reinterpret_cast<MonsterT *>(value);
2959 delete ptr;
2960 break;
2961 }
2962 case AnyAmbiguousAliases_M3: {
2963 auto ptr = reinterpret_cast<MonsterT *>(value);
2964 delete ptr;
2965 break;
2966 }
2967 default: break;
2968 }
2969 value = nullptr;
2970 type = AnyAmbiguousAliases_NONE;
2971 }
2972
2973 inline const flatbuffers::TypeTable *ColorTypeTable() {
2974 static const flatbuffers::TypeCode type_codes[] = {
2975 { flatbuffers::ET_CHAR, 0, 0 },
2976 { flatbuffers::ET_CHAR, 0, 0 },
2977 { flatbuffers::ET_CHAR, 0, 0 }
2978 };
2979 static const flatbuffers::TypeFunction type_refs[] = {
2980 ColorTypeTable
2981 };
2982 static const int64_t values[] = { 1, 2, 8 };
2983 static const char * const names[] = {
2984 "Red",
2985 "Green",
2986 "Blue"
2987 };
2988 static const flatbuffers::TypeTable tt = {
2989 flatbuffers::ST_ENUM, 3, type_codes, type_refs, values, names
2990 };
2991 return &tt;
2992 }
2993
2994 inline const flatbuffers::TypeTable *AnyTypeTable() {
2995 static const flatbuffers::TypeCode type_codes[] = {
2996 { flatbuffers::ET_SEQUENCE, 0, -1 },
2997 { flatbuffers::ET_SEQUENCE, 0, 0 },
2998 { flatbuffers::ET_SEQUENCE, 0, 1 },
2999 { flatbuffers::ET_SEQUENCE, 0, 2 }
3000 };
3001 static const flatbuffers::TypeFunction type_refs[] = {
3002 MonsterTypeTable,
3003 TestSimpleTableWithEnumTypeTable,
3004 MyGame::Example2::MonsterTypeTable
3005 };
3006 static const char * const names[] = {
3007 "NONE",
3008 "Monster",
3009 "TestSimpleTableWithEnum",
3010 "MyGame_Example2_Monster"
3011 };
3012 static const flatbuffers::TypeTable tt = {
3013 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names
3014 };
3015 return &tt;
3016 }
3017
3018 inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() {
3019 static const flatbuffers::TypeCode type_codes[] = {
3020 { flatbuffers::ET_SEQUENCE, 0, -1 },
3021 { flatbuffers::ET_SEQUENCE, 0, 0 },
3022 { flatbuffers::ET_SEQUENCE, 0, 1 },
3023 { flatbuffers::ET_SEQUENCE, 0, 2 }
3024 };
3025 static const flatbuffers::TypeFunction type_refs[] = {
3026 MonsterTypeTable,
3027 TestSimpleTableWithEnumTypeTable,
3028 MyGame::Example2::MonsterTypeTable
3029 };
3030 static const char * const names[] = {
3031 "NONE",
3032 "M",
3033 "T",
3034 "M2"
3035 };
3036 static const flatbuffers::TypeTable tt = {
3037 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names
3038 };
3039 return &tt;
3040 }
3041
3042 inline const flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() {
3043 static const flatbuffers::TypeCode type_codes[] = {
3044 { flatbuffers::ET_SEQUENCE, 0, -1 },
3045 { flatbuffers::ET_SEQUENCE, 0, 0 },
3046 { flatbuffers::ET_SEQUENCE, 0, 0 },
3047 { flatbuffers::ET_SEQUENCE, 0, 0 }
3048 };
3049 static const flatbuffers::TypeFunction type_refs[] = {
3050 MonsterTypeTable
3051 };
3052 static const char * const names[] = {
3053 "NONE",
3054 "M1",
3055 "M2",
3056 "M3"
3057 };
3058 static const flatbuffers::TypeTable tt = {
3059 flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, names
3060 };
3061 return &tt;
3062 }
3063
3064 } // namespace Example
3065
3066 inline const flatbuffers::TypeTable *InParentNamespaceTypeTable() {
3067 static const flatbuffers::TypeTable tt = {
3068 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr
3069 };
3070 return &tt;
3071 }
3072
3073 namespace Example2 {
3074
3075 inline const flatbuffers::TypeTable *MonsterTypeTable() {
3076 static const flatbuffers::TypeTable tt = {
3077 flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr
3078 };
3079 return &tt;
3080 }
3081
3082 } // namespace Example2
3083
3084 namespace Example {
3085
3086 inline const flatbuffers::TypeTable *TestTypeTable() {
3087 static const flatbuffers::TypeCode type_codes[] = {
3088 { flatbuffers::ET_SHORT, 0, -1 },
3089 { flatbuffers::ET_CHAR, 0, -1 }
3090 };
3091 static const int64_t values[] = { 0, 2, 4 };
3092 static const char * const names[] = {
3093 "a",
3094 "b"
3095 };
3096 static const flatbuffers::TypeTable tt = {
3097 flatbuffers::ST_STRUCT, 2, type_codes, nullptr, values, names
3098 };
3099 return &tt;
3100 }
3101
3102 inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() {
3103 static const flatbuffers::TypeCode type_codes[] = {
3104 { flatbuffers::ET_CHAR, 0, 0 }
3105 };
3106 static const flatbuffers::TypeFunction type_refs[] = {
3107 ColorTypeTable
3108 };
3109 static const char * const names[] = {
3110 "color"
3111 };
3112 static const flatbuffers::TypeTable tt = {
3113 flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, names
3114 };
3115 return &tt;
3116 }
3117
3118 inline const flatbuffers::TypeTable *Vec3TypeTable() {
3119 static const flatbuffers::TypeCode type_codes[] = {
3120 { flatbuffers::ET_FLOAT, 0, -1 },
3121 { flatbuffers::ET_FLOAT, 0, -1 },
3122 { flatbuffers::ET_FLOAT, 0, -1 },
3123 { flatbuffers::ET_DOUBLE, 0, -1 },
3124 { flatbuffers::ET_CHAR, 0, 0 },
3125 { flatbuffers::ET_SEQUENCE, 0, 1 }
3126 };
3127 static const flatbuffers::TypeFunction type_refs[] = {
3128 ColorTypeTable,
3129 TestTypeTable
3130 };
3131 static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 };
3132 static const char * const names[] = {
3133 "x",
3134 "y",
3135 "z",
3136 "test1",
3137 "test2",
3138 "test3"
3139 };
3140 static const flatbuffers::TypeTable tt = {
3141 flatbuffers::ST_STRUCT, 6, type_codes, type_refs, values, names
3142 };
3143 return &tt;
3144 }
3145
3146 inline const flatbuffers::TypeTable *AbilityTypeTable() {
3147 static const flatbuffers::TypeCode type_codes[] = {
3148 { flatbuffers::ET_UINT, 0, -1 },
3149 { flatbuffers::ET_UINT, 0, -1 }
3150 };
3151 static const int64_t values[] = { 0, 4, 8 };
3152 static const char * const names[] = {
3153 "id",
3154 "distance"
3155 };
3156 static const flatbuffers::TypeTable tt = {
3157 flatbuffers::ST_STRUCT, 2, type_codes, nullptr, values, names
3158 };
3159 return &tt;
3160 }
3161
3162 inline const flatbuffers::TypeTable *StatTypeTable() {
3163 static const flatbuffers::TypeCode type_codes[] = {
3164 { flatbuffers::ET_STRING, 0, -1 },
3165 { flatbuffers::ET_LONG, 0, -1 },
3166 { flatbuffers::ET_USHORT, 0, -1 }
3167 };
3168 static const char * const names[] = {
3169 "id",
3170 "val",
3171 "count"
3172 };
3173 static const flatbuffers::TypeTable tt = {
3174 flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, names
3175 };
3176 return &tt;
3177 }
3178
3179 inline const flatbuffers::TypeTable *ReferrableTypeTable() {
3180 static const flatbuffers::TypeCode type_codes[] = {
3181 { flatbuffers::ET_ULONG, 0, -1 }
3182 };
3183 static const char * const names[] = {
3184 "id"
3185 };
3186 static const flatbuffers::TypeTable tt = {
3187 flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, names
3188 };
3189 return &tt;
3190 }
3191
3192 inline const flatbuffers::TypeTable *MonsterTypeTable() {
3193 static const flatbuffers::TypeCode type_codes[] = {
3194 { flatbuffers::ET_SEQUENCE, 0, 0 },
3195 { flatbuffers::ET_SHORT, 0, -1 },
3196 { flatbuffers::ET_SHORT, 0, -1 },
3197 { flatbuffers::ET_STRING, 0, -1 },
3198 { flatbuffers::ET_BOOL, 0, -1 },
3199 { flatbuffers::ET_UCHAR, 1, -1 },
3200 { flatbuffers::ET_CHAR, 0, 1 },
3201 { flatbuffers::ET_UTYPE, 0, 2 },
3202 { flatbuffers::ET_SEQUENCE, 0, 2 },
3203 { flatbuffers::ET_SEQUENCE, 1, 3 },
3204 { flatbuffers::ET_STRING, 1, -1 },
3205 { flatbuffers::ET_SEQUENCE, 1, 4 },
3206 { flatbuffers::ET_SEQUENCE, 0, 4 },
3207 { flatbuffers::ET_UCHAR, 1, -1 },
3208 { flatbuffers::ET_SEQUENCE, 0, 5 },
3209 { flatbuffers::ET_BOOL, 0, -1 },
3210 { flatbuffers::ET_INT, 0, -1 },
3211 { flatbuffers::ET_UINT, 0, -1 },
3212 { flatbuffers::ET_LONG, 0, -1 },
3213 { flatbuffers::ET_ULONG, 0, -1 },
3214 { flatbuffers::ET_INT, 0, -1 },
3215 { flatbuffers::ET_UINT, 0, -1 },
3216 { flatbuffers::ET_LONG, 0, -1 },
3217 { flatbuffers::ET_ULONG, 0, -1 },
3218 { flatbuffers::ET_BOOL, 1, -1 },
3219 { flatbuffers::ET_FLOAT, 0, -1 },
3220 { flatbuffers::ET_FLOAT, 0, -1 },
3221 { flatbuffers::ET_FLOAT, 0, -1 },
3222 { flatbuffers::ET_STRING, 1, -1 },
3223 { flatbuffers::ET_SEQUENCE, 1, 6 },
3224 { flatbuffers::ET_UCHAR, 1, -1 },
3225 { flatbuffers::ET_SEQUENCE, 1, 3 },
3226 { flatbuffers::ET_LONG, 1, -1 },
3227 { flatbuffers::ET_DOUBLE, 1, -1 },
3228 { flatbuffers::ET_SEQUENCE, 0, 7 },
3229 { flatbuffers::ET_SEQUENCE, 1, 8 },
3230 { flatbuffers::ET_ULONG, 0, -1 },
3231 { flatbuffers::ET_ULONG, 1, -1 },
3232 { flatbuffers::ET_SEQUENCE, 1, 8 },
3233 { flatbuffers::ET_ULONG, 0, -1 },
3234 { flatbuffers::ET_ULONG, 1, -1 },
3235 { flatbuffers::ET_ULONG, 0, -1 },
3236 { flatbuffers::ET_ULONG, 1, -1 },
3237 { flatbuffers::ET_UTYPE, 0, 9 },
3238 { flatbuffers::ET_SEQUENCE, 0, 9 },
3239 { flatbuffers::ET_UTYPE, 0, 10 },
3240 { flatbuffers::ET_SEQUENCE, 0, 10 },
3241 { flatbuffers::ET_CHAR, 1, 1 }
3242 };
3243 static const flatbuffers::TypeFunction type_refs[] = {
3244 Vec3TypeTable,
3245 ColorTypeTable,
3246 AnyTypeTable,
3247 TestTypeTable,
3248 MonsterTypeTable,
3249 StatTypeTable,
3250 AbilityTypeTable,
3251 MyGame::InParentNamespaceTypeTable,
3252 ReferrableTypeTable,
3253 AnyUniqueAliasesTypeTable,
3254 AnyAmbiguousAliasesTypeTable
3255 };
3256 static const char * const names[] = {
3257 "pos",
3258 "mana",
3259 "hp",
3260 "name",
3261 "friendly",
3262 "inventory",
3263 "color",
3264 "test_type",
3265 "test",
3266 "test4",
3267 "testarrayofstring",
3268 "testarrayoftables",
3269 "enemy",
3270 "testnestedflatbuffer",
3271 "testempty",
3272 "testbool",
3273 "testhashs32_fnv1",
3274 "testhashu32_fnv1",
3275 "testhashs64_fnv1",
3276 "testhashu64_fnv1",
3277 "testhashs32_fnv1a",
3278 "testhashu32_fnv1a",
3279 "testhashs64_fnv1a",
3280 "testhashu64_fnv1a",
3281 "testarrayofbools",
3282 "testf",
3283 "testf2",
3284 "testf3",
3285 "testarrayofstring2",
3286 "testarrayofsortedstruct",
3287 "flex",
3288 "test5",
3289 "vector_of_longs",
3290 "vector_of_doubles",
3291 "parent_namespace_test",
3292 "vector_of_referrables",
3293 "single_weak_reference",
3294 "vector_of_weak_references",
3295 "vector_of_strong_referrables",
3296 "co_owning_reference",
3297 "vector_of_co_owning_references",
3298 "non_owning_reference",
3299 "vector_of_non_owning_references",
3300 "any_unique_type",
3301 "any_unique",
3302 "any_ambiguous_type",
3303 "any_ambiguous",
3304 "vector_of_enums"
3305 };
3306 static const flatbuffers::TypeTable tt = {
3307 flatbuffers::ST_TABLE, 48, type_codes, type_refs, nullptr, names
3308 };
3309 return &tt;
3310 }
3311
3312 inline const flatbuffers::TypeTable *TypeAliasesTypeTable() {
3313 static const flatbuffers::TypeCode type_codes[] = {
3314 { flatbuffers::ET_CHAR, 0, -1 },
3315 { flatbuffers::ET_UCHAR, 0, -1 },
3316 { flatbuffers::ET_SHORT, 0, -1 },
3317 { flatbuffers::ET_USHORT, 0, -1 },
3318 { flatbuffers::ET_INT, 0, -1 },
3319 { flatbuffers::ET_UINT, 0, -1 },
3320 { flatbuffers::ET_LONG, 0, -1 },
3321 { flatbuffers::ET_ULONG, 0, -1 },
3322 { flatbuffers::ET_FLOAT, 0, -1 },
3323 { flatbuffers::ET_DOUBLE, 0, -1 },
3324 { flatbuffers::ET_CHAR, 1, -1 },
3325 { flatbuffers::ET_DOUBLE, 1, -1 }
3326 };
3327 static const char * const names[] = {
3328 "i8",
3329 "u8",
3330 "i16",
3331 "u16",
3332 "i32",
3333 "u32",
3334 "i64",
3335 "u64",
3336 "f32",
3337 "f64",
3338 "v8",
3339 "vf64"
3340 };
3341 static const flatbuffers::TypeTable tt = {
3342 flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, names
3343 };
3344 return &tt;
3345 }
3346
3347 inline const MyGame::Example::Monster *GetMonster(const void *buf) {
3348 return flatbuffers::GetRoot<MyGame::Example::Monster>(buf);
3349 }
3350
3351 inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) {
3352 return flatbuffers::GetSizePrefixedRoot<MyGame::Example::Monster>(buf);
3353 }
3354
3355 inline Monster *GetMutableMonster(void *buf) {
3356 return flatbuffers::GetMutableRoot<Monster>(buf);
3357 }
3358
3359 inline const char *MonsterIdentifier() {
3360 return "MONS";
3361 }
3362
3363 inline bool MonsterBufferHasIdentifier(const void *buf) {
3364 return flatbuffers::BufferHasIdentifier(
3365 buf, MonsterIdentifier());
3366 }
3367
3368 inline bool VerifyMonsterBuffer(
3369 flatbuffers::Verifier &verifier) {
3370 return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
3371 }
3372
3373 inline bool VerifySizePrefixedMonsterBuffer(
3374 flatbuffers::Verifier &verifier) {
3375 return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
3376 }
3377
3378 inline const char *MonsterExtension() {
3379 return "mon";
3380 }
3381
3382 inline void FinishMonsterBuffer(
3383 flatbuffers::FlatBufferBuilder &fbb,
3384 flatbuffers::Offset<MyGame::Example::Monster> root) {
3385 fbb.Finish(root, MonsterIdentifier());
3386 }
3387
3388 inline void FinishSizePrefixedMonsterBuffer(
3389 flatbuffers::FlatBufferBuilder &fbb,
3390 flatbuffers::Offset<MyGame::Example::Monster> root) {
3391 fbb.FinishSizePrefixed(root, MonsterIdentifier());
3392 }
3393
3394 inline flatbuffers::unique_ptr<MonsterT> UnPackMonster(
3395 const void *buf,
3396 const flatbuffers::resolver_function_t *res = nullptr) {
3397 return flatbuffers::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res));
3398 }
3399
3400 } // namespace Example
3401 } // namespace MyGame
3402
3403 #endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
3404