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