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