1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_
5 #define FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 namespace MyGame {
10 namespace Sample {
11
12 struct Vec3;
13
14 struct Monster;
15 struct MonsterT;
16
17 struct Weapon;
18 struct WeaponT;
19
20 enum Color {
21 Color_Red = 0,
22 Color_Green = 1,
23 Color_Blue = 2,
24 Color_MIN = Color_Red,
25 Color_MAX = Color_Blue
26 };
27
EnumValuesColor()28 inline Color (&EnumValuesColor())[3] {
29 static Color values[] = {
30 Color_Red,
31 Color_Green,
32 Color_Blue
33 };
34 return values;
35 }
36
EnumNamesColor()37 inline const char **EnumNamesColor() {
38 static const char *names[] = {
39 "Red",
40 "Green",
41 "Blue",
42 nullptr
43 };
44 return names;
45 }
46
EnumNameColor(Color e)47 inline const char *EnumNameColor(Color e) {
48 const size_t index = static_cast<int>(e);
49 return EnumNamesColor()[index];
50 }
51
52 enum Equipment {
53 Equipment_NONE = 0,
54 Equipment_Weapon = 1,
55 Equipment_MIN = Equipment_NONE,
56 Equipment_MAX = Equipment_Weapon
57 };
58
EnumValuesEquipment()59 inline Equipment (&EnumValuesEquipment())[2] {
60 static Equipment values[] = {
61 Equipment_NONE,
62 Equipment_Weapon
63 };
64 return values;
65 }
66
EnumNamesEquipment()67 inline const char **EnumNamesEquipment() {
68 static const char *names[] = {
69 "NONE",
70 "Weapon",
71 nullptr
72 };
73 return names;
74 }
75
EnumNameEquipment(Equipment e)76 inline const char *EnumNameEquipment(Equipment e) {
77 const size_t index = static_cast<int>(e);
78 return EnumNamesEquipment()[index];
79 }
80
81 template<typename T> struct EquipmentTraits {
82 static const Equipment enum_value = Equipment_NONE;
83 };
84
85 template<> struct EquipmentTraits<Weapon> {
86 static const Equipment enum_value = Equipment_Weapon;
87 };
88
89 struct EquipmentUnion {
90 Equipment type;
91 void *value;
92
93 EquipmentUnion() : type(Equipment_NONE), value(nullptr) {}
94 EquipmentUnion(EquipmentUnion&& u) FLATBUFFERS_NOEXCEPT :
95 type(Equipment_NONE), value(nullptr)
96 { std::swap(type, u.type); std::swap(value, u.value); }
97 EquipmentUnion(const EquipmentUnion &) FLATBUFFERS_NOEXCEPT;
98 EquipmentUnion &operator=(const EquipmentUnion &u) FLATBUFFERS_NOEXCEPT
99 { EquipmentUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
100 EquipmentUnion &operator=(EquipmentUnion &&u) FLATBUFFERS_NOEXCEPT
101 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
102 ~EquipmentUnion() { Reset(); }
103
104 void Reset();
105
106 #ifndef FLATBUFFERS_CPP98_STL
107 template <typename T>
108 void Set(T&& val) {
109 Reset();
110 type = EquipmentTraits<typename T::TableType>::enum_value;
111 if (type != Equipment_NONE) {
112 value = new T(std::forward<T>(val));
113 }
114 }
115 #endif // FLATBUFFERS_CPP98_STL
116
117 static void *UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver);
118 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
119
120 WeaponT *AsWeapon() {
121 return type == Equipment_Weapon ?
122 reinterpret_cast<WeaponT *>(value) : nullptr;
123 }
124 const WeaponT *AsWeapon() const {
125 return type == Equipment_Weapon ?
126 reinterpret_cast<const WeaponT *>(value) : nullptr;
127 }
128 };
129
130 bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type);
131 bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
132
133 MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
134 private:
135 float x_;
136 float y_;
137 float z_;
138
139 public:
140 Vec3() {
141 memset(this, 0, sizeof(Vec3));
142 }
143 Vec3(float _x, float _y, float _z)
144 : x_(flatbuffers::EndianScalar(_x)),
145 y_(flatbuffers::EndianScalar(_y)),
146 z_(flatbuffers::EndianScalar(_z)) {
147 }
148 float x() const {
149 return flatbuffers::EndianScalar(x_);
150 }
151 void mutate_x(float _x) {
152 flatbuffers::WriteScalar(&x_, _x);
153 }
154 float y() const {
155 return flatbuffers::EndianScalar(y_);
156 }
157 void mutate_y(float _y) {
158 flatbuffers::WriteScalar(&y_, _y);
159 }
160 float z() const {
161 return flatbuffers::EndianScalar(z_);
162 }
163 void mutate_z(float _z) {
164 flatbuffers::WriteScalar(&z_, _z);
165 }
166 };
167 STRUCT_END(Vec3, 12);
168
169 struct MonsterT : public flatbuffers::NativeTable {
170 typedef Monster TableType;
171 flatbuffers::unique_ptr<Vec3> pos;
172 int16_t mana;
173 int16_t hp;
174 std::string name;
175 std::vector<uint8_t> inventory;
176 Color color;
177 std::vector<flatbuffers::unique_ptr<WeaponT>> weapons;
178 EquipmentUnion equipped;
179 MonsterT()
180 : mana(150),
181 hp(100),
182 color(Color_Blue) {
183 }
184 };
185
186 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
187 typedef MonsterT NativeTableType;
188 enum {
189 VT_POS = 4,
190 VT_MANA = 6,
191 VT_HP = 8,
192 VT_NAME = 10,
193 VT_INVENTORY = 14,
194 VT_COLOR = 16,
195 VT_WEAPONS = 18,
196 VT_EQUIPPED_TYPE = 20,
197 VT_EQUIPPED = 22
198 };
199 const Vec3 *pos() const {
200 return GetStruct<const Vec3 *>(VT_POS);
201 }
202 Vec3 *mutable_pos() {
203 return GetStruct<Vec3 *>(VT_POS);
204 }
205 int16_t mana() const {
206 return GetField<int16_t>(VT_MANA, 150);
207 }
208 bool mutate_mana(int16_t _mana) {
209 return SetField<int16_t>(VT_MANA, _mana, 150);
210 }
211 int16_t hp() const {
212 return GetField<int16_t>(VT_HP, 100);
213 }
214 bool mutate_hp(int16_t _hp) {
215 return SetField<int16_t>(VT_HP, _hp, 100);
216 }
217 const flatbuffers::String *name() const {
218 return GetPointer<const flatbuffers::String *>(VT_NAME);
219 }
220 flatbuffers::String *mutable_name() {
221 return GetPointer<flatbuffers::String *>(VT_NAME);
222 }
223 const flatbuffers::Vector<uint8_t> *inventory() const {
224 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
225 }
226 flatbuffers::Vector<uint8_t> *mutable_inventory() {
227 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
228 }
229 Color color() const {
230 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 2));
231 }
232 bool mutate_color(Color _color) {
233 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2);
234 }
235 const flatbuffers::Vector<flatbuffers::Offset<Weapon>> *weapons() const {
236 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Weapon>> *>(VT_WEAPONS);
237 }
238 flatbuffers::Vector<flatbuffers::Offset<Weapon>> *mutable_weapons() {
239 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Weapon>> *>(VT_WEAPONS);
240 }
241 Equipment equipped_type() const {
242 return static_cast<Equipment>(GetField<uint8_t>(VT_EQUIPPED_TYPE, 0));
243 }
244 bool mutate_equipped_type(Equipment _equipped_type) {
245 return SetField<uint8_t>(VT_EQUIPPED_TYPE, static_cast<uint8_t>(_equipped_type), 0);
246 }
247 const void *equipped() const {
248 return GetPointer<const void *>(VT_EQUIPPED);
249 }
250 template<typename T> const T *equipped_as() const;
251 const Weapon *equipped_as_Weapon() const {
252 return equipped_type() == Equipment_Weapon ? static_cast<const Weapon *>(equipped()) : nullptr;
253 }
254 void *mutable_equipped() {
255 return GetPointer<void *>(VT_EQUIPPED);
256 }
257 bool Verify(flatbuffers::Verifier &verifier) const {
258 return VerifyTableStart(verifier) &&
259 VerifyField<Vec3>(verifier, VT_POS) &&
260 VerifyField<int16_t>(verifier, VT_MANA) &&
261 VerifyField<int16_t>(verifier, VT_HP) &&
262 VerifyOffset(verifier, VT_NAME) &&
263 verifier.Verify(name()) &&
264 VerifyOffset(verifier, VT_INVENTORY) &&
265 verifier.Verify(inventory()) &&
266 VerifyField<int8_t>(verifier, VT_COLOR) &&
267 VerifyOffset(verifier, VT_WEAPONS) &&
268 verifier.Verify(weapons()) &&
269 verifier.VerifyVectorOfTables(weapons()) &&
270 VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE) &&
271 VerifyOffset(verifier, VT_EQUIPPED) &&
272 VerifyEquipment(verifier, equipped(), equipped_type()) &&
273 verifier.EndTable();
274 }
275 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
276 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
277 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
278 };
279
280 template<> inline const Weapon *Monster::equipped_as<Weapon>() const {
281 return equipped_as_Weapon();
282 }
283
284 struct MonsterBuilder {
285 flatbuffers::FlatBufferBuilder &fbb_;
286 flatbuffers::uoffset_t start_;
287 void add_pos(const Vec3 *pos) {
288 fbb_.AddStruct(Monster::VT_POS, pos);
289 }
290 void add_mana(int16_t mana) {
291 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
292 }
293 void add_hp(int16_t hp) {
294 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
295 }
296 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
297 fbb_.AddOffset(Monster::VT_NAME, name);
298 }
299 void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) {
300 fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
301 }
302 void add_color(Color color) {
303 fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 2);
304 }
305 void add_weapons(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Weapon>>> weapons) {
306 fbb_.AddOffset(Monster::VT_WEAPONS, weapons);
307 }
308 void add_equipped_type(Equipment equipped_type) {
309 fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0);
310 }
311 void add_equipped(flatbuffers::Offset<void> equipped) {
312 fbb_.AddOffset(Monster::VT_EQUIPPED, equipped);
313 }
314 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
315 : fbb_(_fbb) {
316 start_ = fbb_.StartTable();
317 }
318 MonsterBuilder &operator=(const MonsterBuilder &);
319 flatbuffers::Offset<Monster> Finish() {
320 const auto end = fbb_.EndTable(start_);
321 auto o = flatbuffers::Offset<Monster>(end);
322 return o;
323 }
324 };
325
326 inline flatbuffers::Offset<Monster> CreateMonster(
327 flatbuffers::FlatBufferBuilder &_fbb,
328 const Vec3 *pos = 0,
329 int16_t mana = 150,
330 int16_t hp = 100,
331 flatbuffers::Offset<flatbuffers::String> name = 0,
332 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
333 Color color = Color_Blue,
334 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Weapon>>> weapons = 0,
335 Equipment equipped_type = Equipment_NONE,
336 flatbuffers::Offset<void> equipped = 0) {
337 MonsterBuilder builder_(_fbb);
338 builder_.add_equipped(equipped);
339 builder_.add_weapons(weapons);
340 builder_.add_inventory(inventory);
341 builder_.add_name(name);
342 builder_.add_pos(pos);
343 builder_.add_hp(hp);
344 builder_.add_mana(mana);
345 builder_.add_equipped_type(equipped_type);
346 builder_.add_color(color);
347 return builder_.Finish();
348 }
349
350 inline flatbuffers::Offset<Monster> CreateMonsterDirect(
351 flatbuffers::FlatBufferBuilder &_fbb,
352 const Vec3 *pos = 0,
353 int16_t mana = 150,
354 int16_t hp = 100,
355 const char *name = nullptr,
356 const std::vector<uint8_t> *inventory = nullptr,
357 Color color = Color_Blue,
358 const std::vector<flatbuffers::Offset<Weapon>> *weapons = nullptr,
359 Equipment equipped_type = Equipment_NONE,
360 flatbuffers::Offset<void> equipped = 0) {
361 return MyGame::Sample::CreateMonster(
362 _fbb,
363 pos,
364 mana,
365 hp,
366 name ? _fbb.CreateString(name) : 0,
367 inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0,
368 color,
369 weapons ? _fbb.CreateVector<flatbuffers::Offset<Weapon>>(*weapons) : 0,
370 equipped_type,
371 equipped);
372 }
373
374 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
375
376 struct WeaponT : public flatbuffers::NativeTable {
377 typedef Weapon TableType;
378 std::string name;
379 int16_t damage;
380 WeaponT()
381 : damage(0) {
382 }
383 };
384
385 struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
386 typedef WeaponT NativeTableType;
387 enum {
388 VT_NAME = 4,
389 VT_DAMAGE = 6
390 };
391 const flatbuffers::String *name() const {
392 return GetPointer<const flatbuffers::String *>(VT_NAME);
393 }
394 flatbuffers::String *mutable_name() {
395 return GetPointer<flatbuffers::String *>(VT_NAME);
396 }
397 int16_t damage() const {
398 return GetField<int16_t>(VT_DAMAGE, 0);
399 }
400 bool mutate_damage(int16_t _damage) {
401 return SetField<int16_t>(VT_DAMAGE, _damage, 0);
402 }
403 bool Verify(flatbuffers::Verifier &verifier) const {
404 return VerifyTableStart(verifier) &&
405 VerifyOffset(verifier, VT_NAME) &&
406 verifier.Verify(name()) &&
407 VerifyField<int16_t>(verifier, VT_DAMAGE) &&
408 verifier.EndTable();
409 }
410 WeaponT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
411 void UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
412 static flatbuffers::Offset<Weapon> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
413 };
414
415 struct WeaponBuilder {
416 flatbuffers::FlatBufferBuilder &fbb_;
417 flatbuffers::uoffset_t start_;
418 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
419 fbb_.AddOffset(Weapon::VT_NAME, name);
420 }
421 void add_damage(int16_t damage) {
422 fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0);
423 }
424 explicit WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb)
425 : fbb_(_fbb) {
426 start_ = fbb_.StartTable();
427 }
428 WeaponBuilder &operator=(const WeaponBuilder &);
429 flatbuffers::Offset<Weapon> Finish() {
430 const auto end = fbb_.EndTable(start_);
431 auto o = flatbuffers::Offset<Weapon>(end);
432 return o;
433 }
434 };
435
436 inline flatbuffers::Offset<Weapon> CreateWeapon(
437 flatbuffers::FlatBufferBuilder &_fbb,
438 flatbuffers::Offset<flatbuffers::String> name = 0,
439 int16_t damage = 0) {
440 WeaponBuilder builder_(_fbb);
441 builder_.add_name(name);
442 builder_.add_damage(damage);
443 return builder_.Finish();
444 }
445
446 inline flatbuffers::Offset<Weapon> CreateWeaponDirect(
447 flatbuffers::FlatBufferBuilder &_fbb,
448 const char *name = nullptr,
449 int16_t damage = 0) {
450 return MyGame::Sample::CreateWeapon(
451 _fbb,
452 name ? _fbb.CreateString(name) : 0,
453 damage);
454 }
455
456 flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
457
458 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
459 auto _o = new MonsterT();
460 UnPackTo(_o, _resolver);
461 return _o;
462 }
463
464 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
465 (void)_o;
466 (void)_resolver;
467 { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<Vec3>(new Vec3(*_e)); };
468 { auto _e = mana(); _o->mana = _e; };
469 { auto _e = hp(); _o->hp = _e; };
470 { auto _e = name(); if (_e) _o->name = _e->str(); };
471 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory[_i] = _e->Get(_i); } } };
472 { auto _e = color(); _o->color = _e; };
473 { auto _e = weapons(); if (_e) { _o->weapons.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weapons[_i] = flatbuffers::unique_ptr<WeaponT>(_e->Get(_i)->UnPack(_resolver)); } } };
474 { auto _e = equipped_type(); _o->equipped.type = _e; };
475 { auto _e = equipped(); if (_e) _o->equipped.value = EquipmentUnion::UnPack(_e, equipped_type(), _resolver); };
476 }
477
478 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
479 return CreateMonster(_fbb, _o, _rehasher);
480 }
481
482 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
483 (void)_rehasher;
484 (void)_o;
485 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
486 auto _pos = _o->pos ? _o->pos.get() : 0;
487 auto _mana = _o->mana;
488 auto _hp = _o->hp;
489 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
490 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
491 auto _color = _o->color;
492 auto _weapons = _o->weapons.size() ? _fbb.CreateVector<flatbuffers::Offset<Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
493 auto _equipped_type = _o->equipped.type;
494 auto _equipped = _o->equipped.Pack(_fbb);
495 return MyGame::Sample::CreateMonster(
496 _fbb,
497 _pos,
498 _mana,
499 _hp,
500 _name,
501 _inventory,
502 _color,
503 _weapons,
504 _equipped_type,
505 _equipped);
506 }
507
508 inline WeaponT *Weapon::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
509 auto _o = new WeaponT();
510 UnPackTo(_o, _resolver);
511 return _o;
512 }
513
514 inline void Weapon::UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver) const {
515 (void)_o;
516 (void)_resolver;
517 { auto _e = name(); if (_e) _o->name = _e->str(); };
518 { auto _e = damage(); _o->damage = _e; };
519 }
520
521 inline flatbuffers::Offset<Weapon> Weapon::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
522 return CreateWeapon(_fbb, _o, _rehasher);
523 }
524
525 inline flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
526 (void)_rehasher;
527 (void)_o;
528 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WeaponT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
529 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
530 auto _damage = _o->damage;
531 return MyGame::Sample::CreateWeapon(
532 _fbb,
533 _name,
534 _damage);
535 }
536
537 inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type) {
538 switch (type) {
539 case Equipment_NONE: {
540 return true;
541 }
542 case Equipment_Weapon: {
543 auto ptr = reinterpret_cast<const Weapon *>(obj);
544 return verifier.VerifyTable(ptr);
545 }
546 default: return false;
547 }
548 }
549
550 inline bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
551 if (values->size() != types->size()) return false;
552 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
553 if (!VerifyEquipment(
554 verifier, values->Get(i), types->GetEnum<Equipment>(i))) {
555 return false;
556 }
557 }
558 return true;
559 }
560
561 inline void *EquipmentUnion::UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver) {
562 switch (type) {
563 case Equipment_Weapon: {
564 auto ptr = reinterpret_cast<const Weapon *>(obj);
565 return ptr->UnPack(resolver);
566 }
567 default: return nullptr;
568 }
569 }
570
571 inline flatbuffers::Offset<void> EquipmentUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
572 switch (type) {
573 case Equipment_Weapon: {
574 auto ptr = reinterpret_cast<const WeaponT *>(value);
575 return CreateWeapon(_fbb, ptr, _rehasher).Union();
576 }
577 default: return 0;
578 }
579 }
580
581 inline EquipmentUnion::EquipmentUnion(const EquipmentUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
582 switch (type) {
583 case Equipment_Weapon: {
584 value = new WeaponT(*reinterpret_cast<WeaponT *>(u.value));
585 break;
586 }
587 default:
588 break;
589 }
590 }
591
592 inline void EquipmentUnion::Reset() {
593 switch (type) {
594 case Equipment_Weapon: {
595 auto ptr = reinterpret_cast<WeaponT *>(value);
596 delete ptr;
597 break;
598 }
599 default: break;
600 }
601 value = nullptr;
602 type = Equipment_NONE;
603 }
604
605 inline flatbuffers::TypeTable *Vec3TypeTable();
606
607 inline flatbuffers::TypeTable *MonsterTypeTable();
608
609 inline flatbuffers::TypeTable *WeaponTypeTable();
610
611 inline flatbuffers::TypeTable *ColorTypeTable() {
612 static flatbuffers::TypeCode type_codes[] = {
613 { flatbuffers::ET_CHAR, 0, 0 },
614 { flatbuffers::ET_CHAR, 0, 0 },
615 { flatbuffers::ET_CHAR, 0, 0 }
616 };
617 static flatbuffers::TypeFunction type_refs[] = {
618 ColorTypeTable
619 };
620 static const char *names[] = {
621 "Red",
622 "Green",
623 "Blue"
624 };
625 static flatbuffers::TypeTable tt = {
626 flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, names
627 };
628 return &tt;
629 }
630
631 inline flatbuffers::TypeTable *EquipmentTypeTable() {
632 static flatbuffers::TypeCode type_codes[] = {
633 { flatbuffers::ET_SEQUENCE, 0, -1 },
634 { flatbuffers::ET_SEQUENCE, 0, 0 }
635 };
636 static flatbuffers::TypeFunction type_refs[] = {
637 WeaponTypeTable
638 };
639 static const char *names[] = {
640 "NONE",
641 "Weapon"
642 };
643 static flatbuffers::TypeTable tt = {
644 flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, names
645 };
646 return &tt;
647 }
648
649 inline flatbuffers::TypeTable *Vec3TypeTable() {
650 static flatbuffers::TypeCode type_codes[] = {
651 { flatbuffers::ET_FLOAT, 0, -1 },
652 { flatbuffers::ET_FLOAT, 0, -1 },
653 { flatbuffers::ET_FLOAT, 0, -1 }
654 };
655 static const int32_t values[] = { 0, 4, 8, 12 };
656 static const char *names[] = {
657 "x",
658 "y",
659 "z"
660 };
661 static flatbuffers::TypeTable tt = {
662 flatbuffers::ST_STRUCT, 3, type_codes, nullptr, values, names
663 };
664 return &tt;
665 }
666
667 inline flatbuffers::TypeTable *MonsterTypeTable() {
668 static flatbuffers::TypeCode type_codes[] = {
669 { flatbuffers::ET_SEQUENCE, 0, 0 },
670 { flatbuffers::ET_SHORT, 0, -1 },
671 { flatbuffers::ET_SHORT, 0, -1 },
672 { flatbuffers::ET_STRING, 0, -1 },
673 { flatbuffers::ET_BOOL, 0, -1 },
674 { flatbuffers::ET_UCHAR, 1, -1 },
675 { flatbuffers::ET_CHAR, 0, 1 },
676 { flatbuffers::ET_SEQUENCE, 1, 2 },
677 { flatbuffers::ET_UTYPE, 0, 3 },
678 { flatbuffers::ET_SEQUENCE, 0, 3 }
679 };
680 static flatbuffers::TypeFunction type_refs[] = {
681 Vec3TypeTable,
682 ColorTypeTable,
683 WeaponTypeTable,
684 EquipmentTypeTable
685 };
686 static const char *names[] = {
687 "pos",
688 "mana",
689 "hp",
690 "name",
691 "friendly",
692 "inventory",
693 "color",
694 "weapons",
695 "equipped_type",
696 "equipped"
697 };
698 static flatbuffers::TypeTable tt = {
699 flatbuffers::ST_TABLE, 10, type_codes, type_refs, nullptr, names
700 };
701 return &tt;
702 }
703
704 inline flatbuffers::TypeTable *WeaponTypeTable() {
705 static flatbuffers::TypeCode type_codes[] = {
706 { flatbuffers::ET_STRING, 0, -1 },
707 { flatbuffers::ET_SHORT, 0, -1 }
708 };
709 static const char *names[] = {
710 "name",
711 "damage"
712 };
713 static flatbuffers::TypeTable tt = {
714 flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
715 };
716 return &tt;
717 }
718
719 inline const MyGame::Sample::Monster *GetMonster(const void *buf) {
720 return flatbuffers::GetRoot<MyGame::Sample::Monster>(buf);
721 }
722
723 inline Monster *GetMutableMonster(void *buf) {
724 return flatbuffers::GetMutableRoot<Monster>(buf);
725 }
726
727 inline bool VerifyMonsterBuffer(
728 flatbuffers::Verifier &verifier) {
729 return verifier.VerifyBuffer<MyGame::Sample::Monster>(nullptr);
730 }
731
732 inline void FinishMonsterBuffer(
733 flatbuffers::FlatBufferBuilder &fbb,
734 flatbuffers::Offset<MyGame::Sample::Monster> root) {
735 fbb.Finish(root);
736 }
737
738 inline flatbuffers::unique_ptr<MonsterT> UnPackMonster(
739 const void *buf,
740 const flatbuffers::resolver_function_t *res = nullptr) {
741 return flatbuffers::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res));
742 }
743
744 } // namespace Sample
745 } // namespace MyGame
746
747 #endif // FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_
748