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