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 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12 FLATBUFFERS_VERSION_MINOR == 0 &&
13 FLATBUFFERS_VERSION_REVISION == 7,
14 "Non-compatible flatbuffers version included");
15
16 namespace MyGame {
17 namespace Sample {
18
19 struct Vec3;
20
21 struct Monster;
22 struct MonsterBuilder;
23 struct MonsterT;
24
25 struct Weapon;
26 struct WeaponBuilder;
27 struct WeaponT;
28
29 bool operator==(const Vec3 &lhs, const Vec3 &rhs);
30 bool operator!=(const Vec3 &lhs, const Vec3 &rhs);
31 bool operator==(const MonsterT &lhs, const MonsterT &rhs);
32 bool operator!=(const MonsterT &lhs, const MonsterT &rhs);
33 bool operator==(const WeaponT &lhs, const WeaponT &rhs);
34 bool operator!=(const WeaponT &lhs, const WeaponT &rhs);
35
36 inline const flatbuffers::TypeTable *Vec3TypeTable();
37
38 inline const flatbuffers::TypeTable *MonsterTypeTable();
39
40 inline const flatbuffers::TypeTable *WeaponTypeTable();
41
42 enum Color : int8_t {
43 Color_Red = 0,
44 Color_Green = 1,
45 Color_Blue = 2,
46 Color_MIN = Color_Red,
47 Color_MAX = Color_Blue
48 };
49
EnumValuesColor()50 inline const Color (&EnumValuesColor())[3] {
51 static const Color values[] = {
52 Color_Red,
53 Color_Green,
54 Color_Blue
55 };
56 return values;
57 }
58
EnumNamesColor()59 inline const char * const *EnumNamesColor() {
60 static const char * const names[4] = {
61 "Red",
62 "Green",
63 "Blue",
64 nullptr
65 };
66 return names;
67 }
68
EnumNameColor(Color e)69 inline const char *EnumNameColor(Color e) {
70 if (flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return "";
71 const size_t index = static_cast<size_t>(e);
72 return EnumNamesColor()[index];
73 }
74
75 enum Equipment : uint8_t {
76 Equipment_NONE = 0,
77 Equipment_Weapon = 1,
78 Equipment_MIN = Equipment_NONE,
79 Equipment_MAX = Equipment_Weapon
80 };
81
EnumValuesEquipment()82 inline const Equipment (&EnumValuesEquipment())[2] {
83 static const Equipment values[] = {
84 Equipment_NONE,
85 Equipment_Weapon
86 };
87 return values;
88 }
89
EnumNamesEquipment()90 inline const char * const *EnumNamesEquipment() {
91 static const char * const names[3] = {
92 "NONE",
93 "Weapon",
94 nullptr
95 };
96 return names;
97 }
98
EnumNameEquipment(Equipment e)99 inline const char *EnumNameEquipment(Equipment e) {
100 if (flatbuffers::IsOutRange(e, Equipment_NONE, Equipment_Weapon)) return "";
101 const size_t index = static_cast<size_t>(e);
102 return EnumNamesEquipment()[index];
103 }
104
105 template<typename T> struct EquipmentTraits {
106 static const Equipment enum_value = Equipment_NONE;
107 };
108
109 template<> struct EquipmentTraits<MyGame::Sample::Weapon> {
110 static const Equipment enum_value = Equipment_Weapon;
111 };
112
113 template<typename T> struct EquipmentUnionTraits {
114 static const Equipment enum_value = Equipment_NONE;
115 };
116
117 template<> struct EquipmentUnionTraits<MyGame::Sample::WeaponT> {
118 static const Equipment enum_value = Equipment_Weapon;
119 };
120
121 struct EquipmentUnion {
122 Equipment type;
123 void *value;
124
125 EquipmentUnion() : type(Equipment_NONE), value(nullptr) {}
126 EquipmentUnion(EquipmentUnion&& u) FLATBUFFERS_NOEXCEPT :
127 type(Equipment_NONE), value(nullptr)
128 { std::swap(type, u.type); std::swap(value, u.value); }
129 EquipmentUnion(const EquipmentUnion &);
130 EquipmentUnion &operator=(const EquipmentUnion &u)
131 { EquipmentUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
132 EquipmentUnion &operator=(EquipmentUnion &&u) FLATBUFFERS_NOEXCEPT
133 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
134 ~EquipmentUnion() { Reset(); }
135
136 void Reset();
137
138 template <typename T>
139 void Set(T&& val) {
140 typedef typename std::remove_reference<T>::type RT;
141 Reset();
142 type = EquipmentUnionTraits<RT>::enum_value;
143 if (type != Equipment_NONE) {
144 value = new RT(std::forward<T>(val));
145 }
146 }
147
148 static void *UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver);
149 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
150
151 MyGame::Sample::WeaponT *AsWeapon() {
152 return type == Equipment_Weapon ?
153 reinterpret_cast<MyGame::Sample::WeaponT *>(value) : nullptr;
154 }
155 const MyGame::Sample::WeaponT *AsWeapon() const {
156 return type == Equipment_Weapon ?
157 reinterpret_cast<const MyGame::Sample::WeaponT *>(value) : nullptr;
158 }
159 };
160
161
162 inline bool operator==(const EquipmentUnion &lhs, const EquipmentUnion &rhs) {
163 if (lhs.type != rhs.type) return false;
164 switch (lhs.type) {
165 case Equipment_NONE: {
166 return true;
167 }
168 case Equipment_Weapon: {
169 return *(reinterpret_cast<const MyGame::Sample::WeaponT *>(lhs.value)) ==
170 *(reinterpret_cast<const MyGame::Sample::WeaponT *>(rhs.value));
171 }
172 default: {
173 return false;
174 }
175 }
176 }
177
178 inline bool operator!=(const EquipmentUnion &lhs, const EquipmentUnion &rhs) {
179 return !(lhs == rhs);
180 }
181
182 bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type);
183 bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
184
185 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
186 private:
187 float x_;
188 float y_;
189 float z_;
190
191 public:
192 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
193 return Vec3TypeTable();
194 }
195 Vec3()
196 : x_(0),
197 y_(0),
198 z_(0) {
199 }
200 Vec3(float _x, float _y, float _z)
201 : x_(flatbuffers::EndianScalar(_x)),
202 y_(flatbuffers::EndianScalar(_y)),
203 z_(flatbuffers::EndianScalar(_z)) {
204 }
205 float x() const {
206 return flatbuffers::EndianScalar(x_);
207 }
208 void mutate_x(float _x) {
209 flatbuffers::WriteScalar(&x_, _x);
210 }
211 float y() const {
212 return flatbuffers::EndianScalar(y_);
213 }
214 void mutate_y(float _y) {
215 flatbuffers::WriteScalar(&y_, _y);
216 }
217 float z() const {
218 return flatbuffers::EndianScalar(z_);
219 }
220 void mutate_z(float _z) {
221 flatbuffers::WriteScalar(&z_, _z);
222 }
223 };
224 FLATBUFFERS_STRUCT_END(Vec3, 12);
225
226 inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) {
227 return
228 (lhs.x() == rhs.x()) &&
229 (lhs.y() == rhs.y()) &&
230 (lhs.z() == rhs.z());
231 }
232
233 inline bool operator!=(const Vec3 &lhs, const Vec3 &rhs) {
234 return !(lhs == rhs);
235 }
236
237
238 struct MonsterT : public flatbuffers::NativeTable {
239 typedef Monster TableType;
240 flatbuffers::unique_ptr<MyGame::Sample::Vec3> pos{};
241 int16_t mana = 150;
242 int16_t hp = 100;
243 std::string name{};
244 std::vector<uint8_t> inventory{};
245 MyGame::Sample::Color color = MyGame::Sample::Color_Blue;
246 std::vector<flatbuffers::unique_ptr<MyGame::Sample::WeaponT>> weapons{};
247 MyGame::Sample::EquipmentUnion equipped{};
248 std::vector<MyGame::Sample::Vec3> path{};
249 MonsterT() = default;
250 MonsterT(const MonsterT &o);
251 MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
252 MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT;
253 };
254
255 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
256 typedef MonsterT NativeTableType;
257 typedef MonsterBuilder Builder;
258 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
259 return MonsterTypeTable();
260 }
261 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
262 VT_POS = 4,
263 VT_MANA = 6,
264 VT_HP = 8,
265 VT_NAME = 10,
266 VT_INVENTORY = 14,
267 VT_COLOR = 16,
268 VT_WEAPONS = 18,
269 VT_EQUIPPED_TYPE = 20,
270 VT_EQUIPPED = 22,
271 VT_PATH = 24
272 };
273 const MyGame::Sample::Vec3 *pos() const {
274 return GetStruct<const MyGame::Sample::Vec3 *>(VT_POS);
275 }
276 MyGame::Sample::Vec3 *mutable_pos() {
277 return GetStruct<MyGame::Sample::Vec3 *>(VT_POS);
278 }
279 int16_t mana() const {
280 return GetField<int16_t>(VT_MANA, 150);
281 }
282 bool mutate_mana(int16_t _mana = 150) {
283 return SetField<int16_t>(VT_MANA, _mana, 150);
284 }
285 int16_t hp() const {
286 return GetField<int16_t>(VT_HP, 100);
287 }
288 bool mutate_hp(int16_t _hp = 100) {
289 return SetField<int16_t>(VT_HP, _hp, 100);
290 }
291 const flatbuffers::String *name() const {
292 return GetPointer<const flatbuffers::String *>(VT_NAME);
293 }
294 flatbuffers::String *mutable_name() {
295 return GetPointer<flatbuffers::String *>(VT_NAME);
296 }
297 const flatbuffers::Vector<uint8_t> *inventory() const {
298 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
299 }
300 flatbuffers::Vector<uint8_t> *mutable_inventory() {
301 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
302 }
303 MyGame::Sample::Color color() const {
304 return static_cast<MyGame::Sample::Color>(GetField<int8_t>(VT_COLOR, 2));
305 }
306 bool mutate_color(MyGame::Sample::Color _color = static_cast<MyGame::Sample::Color>(2)) {
307 return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2);
308 }
309 const flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons() const {
310 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS);
311 }
312 flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *mutable_weapons() {
313 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS);
314 }
315 MyGame::Sample::Equipment equipped_type() const {
316 return static_cast<MyGame::Sample::Equipment>(GetField<uint8_t>(VT_EQUIPPED_TYPE, 0));
317 }
318 const void *equipped() const {
319 return GetPointer<const void *>(VT_EQUIPPED);
320 }
321 template<typename T> const T *equipped_as() const;
322 const MyGame::Sample::Weapon *equipped_as_Weapon() const {
323 return equipped_type() == MyGame::Sample::Equipment_Weapon ? static_cast<const MyGame::Sample::Weapon *>(equipped()) : nullptr;
324 }
325 void *mutable_equipped() {
326 return GetPointer<void *>(VT_EQUIPPED);
327 }
328 const flatbuffers::Vector<const MyGame::Sample::Vec3 *> *path() const {
329 return GetPointer<const flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
330 }
331 flatbuffers::Vector<const MyGame::Sample::Vec3 *> *mutable_path() {
332 return GetPointer<flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
333 }
334 bool Verify(flatbuffers::Verifier &verifier) const {
335 return VerifyTableStart(verifier) &&
336 VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) &&
337 VerifyField<int16_t>(verifier, VT_MANA, 2) &&
338 VerifyField<int16_t>(verifier, VT_HP, 2) &&
339 VerifyOffset(verifier, VT_NAME) &&
340 verifier.VerifyString(name()) &&
341 VerifyOffset(verifier, VT_INVENTORY) &&
342 verifier.VerifyVector(inventory()) &&
343 VerifyField<int8_t>(verifier, VT_COLOR, 1) &&
344 VerifyOffset(verifier, VT_WEAPONS) &&
345 verifier.VerifyVector(weapons()) &&
346 verifier.VerifyVectorOfTables(weapons()) &&
347 VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE, 1) &&
348 VerifyOffset(verifier, VT_EQUIPPED) &&
349 VerifyEquipment(verifier, equipped(), equipped_type()) &&
350 VerifyOffset(verifier, VT_PATH) &&
351 verifier.VerifyVector(path()) &&
352 verifier.EndTable();
353 }
354 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
355 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
356 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
357 };
358
359 template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sample::Weapon>() const {
360 return equipped_as_Weapon();
361 }
362
363 struct MonsterBuilder {
364 typedef Monster Table;
365 flatbuffers::FlatBufferBuilder &fbb_;
366 flatbuffers::uoffset_t start_;
367 void add_pos(const MyGame::Sample::Vec3 *pos) {
368 fbb_.AddStruct(Monster::VT_POS, pos);
369 }
370 void add_mana(int16_t mana) {
371 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
372 }
373 void add_hp(int16_t hp) {
374 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
375 }
376 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
377 fbb_.AddOffset(Monster::VT_NAME, name);
378 }
379 void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) {
380 fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
381 }
382 void add_color(MyGame::Sample::Color color) {
383 fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 2);
384 }
385 void add_weapons(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons) {
386 fbb_.AddOffset(Monster::VT_WEAPONS, weapons);
387 }
388 void add_equipped_type(MyGame::Sample::Equipment equipped_type) {
389 fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0);
390 }
391 void add_equipped(flatbuffers::Offset<void> equipped) {
392 fbb_.AddOffset(Monster::VT_EQUIPPED, equipped);
393 }
394 void add_path(flatbuffers::Offset<flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path) {
395 fbb_.AddOffset(Monster::VT_PATH, path);
396 }
397 explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
398 : fbb_(_fbb) {
399 start_ = fbb_.StartTable();
400 }
401 flatbuffers::Offset<Monster> Finish() {
402 const auto end = fbb_.EndTable(start_);
403 auto o = flatbuffers::Offset<Monster>(end);
404 return o;
405 }
406 };
407
408 inline flatbuffers::Offset<Monster> CreateMonster(
409 flatbuffers::FlatBufferBuilder &_fbb,
410 const MyGame::Sample::Vec3 *pos = nullptr,
411 int16_t mana = 150,
412 int16_t hp = 100,
413 flatbuffers::Offset<flatbuffers::String> name = 0,
414 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
415 MyGame::Sample::Color color = MyGame::Sample::Color_Blue,
416 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons = 0,
417 MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE,
418 flatbuffers::Offset<void> equipped = 0,
419 flatbuffers::Offset<flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path = 0) {
420 MonsterBuilder builder_(_fbb);
421 builder_.add_path(path);
422 builder_.add_equipped(equipped);
423 builder_.add_weapons(weapons);
424 builder_.add_inventory(inventory);
425 builder_.add_name(name);
426 builder_.add_pos(pos);
427 builder_.add_hp(hp);
428 builder_.add_mana(mana);
429 builder_.add_equipped_type(equipped_type);
430 builder_.add_color(color);
431 return builder_.Finish();
432 }
433
434 inline flatbuffers::Offset<Monster> CreateMonsterDirect(
435 flatbuffers::FlatBufferBuilder &_fbb,
436 const MyGame::Sample::Vec3 *pos = nullptr,
437 int16_t mana = 150,
438 int16_t hp = 100,
439 const char *name = nullptr,
440 const std::vector<uint8_t> *inventory = nullptr,
441 MyGame::Sample::Color color = MyGame::Sample::Color_Blue,
442 const std::vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons = nullptr,
443 MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE,
444 flatbuffers::Offset<void> equipped = 0,
445 const std::vector<MyGame::Sample::Vec3> *path = nullptr) {
446 auto name__ = name ? _fbb.CreateString(name) : 0;
447 auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
448 auto weapons__ = weapons ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Sample::Weapon>>(*weapons) : 0;
449 auto path__ = path ? _fbb.CreateVectorOfStructs<MyGame::Sample::Vec3>(*path) : 0;
450 return MyGame::Sample::CreateMonster(
451 _fbb,
452 pos,
453 mana,
454 hp,
455 name__,
456 inventory__,
457 color,
458 weapons__,
459 equipped_type,
460 equipped,
461 path__);
462 }
463
464 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
465
466 struct WeaponT : public flatbuffers::NativeTable {
467 typedef Weapon TableType;
468 std::string name{};
469 int16_t damage = 0;
470 };
471
472 struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
473 typedef WeaponT NativeTableType;
474 typedef WeaponBuilder Builder;
475 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
476 return WeaponTypeTable();
477 }
478 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
479 VT_NAME = 4,
480 VT_DAMAGE = 6
481 };
482 const flatbuffers::String *name() const {
483 return GetPointer<const flatbuffers::String *>(VT_NAME);
484 }
485 flatbuffers::String *mutable_name() {
486 return GetPointer<flatbuffers::String *>(VT_NAME);
487 }
488 int16_t damage() const {
489 return GetField<int16_t>(VT_DAMAGE, 0);
490 }
491 bool mutate_damage(int16_t _damage = 0) {
492 return SetField<int16_t>(VT_DAMAGE, _damage, 0);
493 }
494 bool Verify(flatbuffers::Verifier &verifier) const {
495 return VerifyTableStart(verifier) &&
496 VerifyOffset(verifier, VT_NAME) &&
497 verifier.VerifyString(name()) &&
498 VerifyField<int16_t>(verifier, VT_DAMAGE, 2) &&
499 verifier.EndTable();
500 }
501 WeaponT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
502 void UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
503 static flatbuffers::Offset<Weapon> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
504 };
505
506 struct WeaponBuilder {
507 typedef Weapon Table;
508 flatbuffers::FlatBufferBuilder &fbb_;
509 flatbuffers::uoffset_t start_;
510 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
511 fbb_.AddOffset(Weapon::VT_NAME, name);
512 }
513 void add_damage(int16_t damage) {
514 fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0);
515 }
516 explicit WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb)
517 : fbb_(_fbb) {
518 start_ = fbb_.StartTable();
519 }
520 flatbuffers::Offset<Weapon> Finish() {
521 const auto end = fbb_.EndTable(start_);
522 auto o = flatbuffers::Offset<Weapon>(end);
523 return o;
524 }
525 };
526
527 inline flatbuffers::Offset<Weapon> CreateWeapon(
528 flatbuffers::FlatBufferBuilder &_fbb,
529 flatbuffers::Offset<flatbuffers::String> name = 0,
530 int16_t damage = 0) {
531 WeaponBuilder builder_(_fbb);
532 builder_.add_name(name);
533 builder_.add_damage(damage);
534 return builder_.Finish();
535 }
536
537 inline flatbuffers::Offset<Weapon> CreateWeaponDirect(
538 flatbuffers::FlatBufferBuilder &_fbb,
539 const char *name = nullptr,
540 int16_t damage = 0) {
541 auto name__ = name ? _fbb.CreateString(name) : 0;
542 return MyGame::Sample::CreateWeapon(
543 _fbb,
544 name__,
545 damage);
546 }
547
548 flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
549
550
551 inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
552 return
553 ((lhs.pos == rhs.pos) || (lhs.pos && rhs.pos && *lhs.pos == *rhs.pos)) &&
554 (lhs.mana == rhs.mana) &&
555 (lhs.hp == rhs.hp) &&
556 (lhs.name == rhs.name) &&
557 (lhs.inventory == rhs.inventory) &&
558 (lhs.color == rhs.color) &&
559 (lhs.weapons.size() == rhs.weapons.size() && std::equal(lhs.weapons.cbegin(), lhs.weapons.cend(), rhs.weapons.cbegin(), [](flatbuffers::unique_ptr<MyGame::Sample::WeaponT> const &a, flatbuffers::unique_ptr<MyGame::Sample::WeaponT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
560 (lhs.equipped == rhs.equipped) &&
561 (lhs.path == rhs.path);
562 }
563
564 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
565 return !(lhs == rhs);
566 }
567
568
569 inline MonsterT::MonsterT(const MonsterT &o)
570 : pos((o.pos) ? new MyGame::Sample::Vec3(*o.pos) : nullptr),
571 mana(o.mana),
572 hp(o.hp),
573 name(o.name),
574 inventory(o.inventory),
575 color(o.color),
576 equipped(o.equipped),
577 path(o.path) {
578 weapons.reserve(o.weapons.size());
579 for (const auto &weapons_ : o.weapons) { weapons.emplace_back((weapons_) ? new MyGame::Sample::WeaponT(*weapons_) : nullptr); }
580 }
581
582 inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
583 std::swap(pos, o.pos);
584 std::swap(mana, o.mana);
585 std::swap(hp, o.hp);
586 std::swap(name, o.name);
587 std::swap(inventory, o.inventory);
588 std::swap(color, o.color);
589 std::swap(weapons, o.weapons);
590 std::swap(equipped, o.equipped);
591 std::swap(path, o.path);
592 return *this;
593 }
594
595 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
596 auto _o = std::unique_ptr<MonsterT>(new MonsterT());
597 UnPackTo(_o.get(), _resolver);
598 return _o.release();
599 }
600
601 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
602 (void)_o;
603 (void)_resolver;
604 { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<MyGame::Sample::Vec3>(new MyGame::Sample::Vec3(*_e)); }
605 { auto _e = mana(); _o->mana = _e; }
606 { auto _e = hp(); _o->hp = _e; }
607 { auto _e = name(); if (_e) _o->name = _e->str(); }
608 { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } }
609 { auto _e = color(); _o->color = _e; }
610 { 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<MyGame::Sample::WeaponT>(_e->Get(_i)->UnPack(_resolver)); } } }
611 { auto _e = equipped_type(); _o->equipped.type = _e; }
612 { auto _e = equipped(); if (_e) _o->equipped.value = MyGame::Sample::EquipmentUnion::UnPack(_e, equipped_type(), _resolver); }
613 { auto _e = path(); if (_e) { _o->path.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->path[_i] = *_e->Get(_i); } } }
614 }
615
616 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
617 return CreateMonster(_fbb, _o, _rehasher);
618 }
619
620 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
621 (void)_rehasher;
622 (void)_o;
623 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
624 auto _pos = _o->pos ? _o->pos.get() : nullptr;
625 auto _mana = _o->mana;
626 auto _hp = _o->hp;
627 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
628 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
629 auto _color = _o->color;
630 auto _weapons = _o->weapons.size() ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
631 auto _equipped_type = _o->equipped.type;
632 auto _equipped = _o->equipped.Pack(_fbb);
633 auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0;
634 return MyGame::Sample::CreateMonster(
635 _fbb,
636 _pos,
637 _mana,
638 _hp,
639 _name,
640 _inventory,
641 _color,
642 _weapons,
643 _equipped_type,
644 _equipped,
645 _path);
646 }
647
648
649 inline bool operator==(const WeaponT &lhs, const WeaponT &rhs) {
650 return
651 (lhs.name == rhs.name) &&
652 (lhs.damage == rhs.damage);
653 }
654
655 inline bool operator!=(const WeaponT &lhs, const WeaponT &rhs) {
656 return !(lhs == rhs);
657 }
658
659
660 inline WeaponT *Weapon::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
661 auto _o = std::unique_ptr<WeaponT>(new WeaponT());
662 UnPackTo(_o.get(), _resolver);
663 return _o.release();
664 }
665
666 inline void Weapon::UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver) const {
667 (void)_o;
668 (void)_resolver;
669 { auto _e = name(); if (_e) _o->name = _e->str(); }
670 { auto _e = damage(); _o->damage = _e; }
671 }
672
673 inline flatbuffers::Offset<Weapon> Weapon::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
674 return CreateWeapon(_fbb, _o, _rehasher);
675 }
676
677 inline flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
678 (void)_rehasher;
679 (void)_o;
680 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WeaponT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
681 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
682 auto _damage = _o->damage;
683 return MyGame::Sample::CreateWeapon(
684 _fbb,
685 _name,
686 _damage);
687 }
688
689 inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type) {
690 switch (type) {
691 case Equipment_NONE: {
692 return true;
693 }
694 case Equipment_Weapon: {
695 auto ptr = reinterpret_cast<const MyGame::Sample::Weapon *>(obj);
696 return verifier.VerifyTable(ptr);
697 }
698 default: return true;
699 }
700 }
701
702 inline bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
703 if (!values || !types) return !values && !types;
704 if (values->size() != types->size()) return false;
705 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
706 if (!VerifyEquipment(
707 verifier, values->Get(i), types->GetEnum<Equipment>(i))) {
708 return false;
709 }
710 }
711 return true;
712 }
713
714 inline void *EquipmentUnion::UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver) {
715 (void)resolver;
716 switch (type) {
717 case Equipment_Weapon: {
718 auto ptr = reinterpret_cast<const MyGame::Sample::Weapon *>(obj);
719 return ptr->UnPack(resolver);
720 }
721 default: return nullptr;
722 }
723 }
724
725 inline flatbuffers::Offset<void> EquipmentUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
726 (void)_rehasher;
727 switch (type) {
728 case Equipment_Weapon: {
729 auto ptr = reinterpret_cast<const MyGame::Sample::WeaponT *>(value);
730 return CreateWeapon(_fbb, ptr, _rehasher).Union();
731 }
732 default: return 0;
733 }
734 }
735
736 inline EquipmentUnion::EquipmentUnion(const EquipmentUnion &u) : type(u.type), value(nullptr) {
737 switch (type) {
738 case Equipment_Weapon: {
739 value = new MyGame::Sample::WeaponT(*reinterpret_cast<MyGame::Sample::WeaponT *>(u.value));
740 break;
741 }
742 default:
743 break;
744 }
745 }
746
747 inline void EquipmentUnion::Reset() {
748 switch (type) {
749 case Equipment_Weapon: {
750 auto ptr = reinterpret_cast<MyGame::Sample::WeaponT *>(value);
751 delete ptr;
752 break;
753 }
754 default: break;
755 }
756 value = nullptr;
757 type = Equipment_NONE;
758 }
759
760 inline const flatbuffers::TypeTable *ColorTypeTable() {
761 static const flatbuffers::TypeCode type_codes[] = {
762 { flatbuffers::ET_CHAR, 0, 0 },
763 { flatbuffers::ET_CHAR, 0, 0 },
764 { flatbuffers::ET_CHAR, 0, 0 }
765 };
766 static const flatbuffers::TypeFunction type_refs[] = {
767 MyGame::Sample::ColorTypeTable
768 };
769 static const char * const names[] = {
770 "Red",
771 "Green",
772 "Blue"
773 };
774 static const flatbuffers::TypeTable tt = {
775 flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
776 };
777 return &tt;
778 }
779
780 inline const flatbuffers::TypeTable *EquipmentTypeTable() {
781 static const flatbuffers::TypeCode type_codes[] = {
782 { flatbuffers::ET_SEQUENCE, 0, -1 },
783 { flatbuffers::ET_SEQUENCE, 0, 0 }
784 };
785 static const flatbuffers::TypeFunction type_refs[] = {
786 MyGame::Sample::WeaponTypeTable
787 };
788 static const char * const names[] = {
789 "NONE",
790 "Weapon"
791 };
792 static const flatbuffers::TypeTable tt = {
793 flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names
794 };
795 return &tt;
796 }
797
798 inline const flatbuffers::TypeTable *Vec3TypeTable() {
799 static const flatbuffers::TypeCode type_codes[] = {
800 { flatbuffers::ET_FLOAT, 0, -1 },
801 { flatbuffers::ET_FLOAT, 0, -1 },
802 { flatbuffers::ET_FLOAT, 0, -1 }
803 };
804 static const int64_t values[] = { 0, 4, 8, 12 };
805 static const char * const names[] = {
806 "x",
807 "y",
808 "z"
809 };
810 static const flatbuffers::TypeTable tt = {
811 flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
812 };
813 return &tt;
814 }
815
816 inline const flatbuffers::TypeTable *MonsterTypeTable() {
817 static const flatbuffers::TypeCode type_codes[] = {
818 { flatbuffers::ET_SEQUENCE, 0, 0 },
819 { flatbuffers::ET_SHORT, 0, -1 },
820 { flatbuffers::ET_SHORT, 0, -1 },
821 { flatbuffers::ET_STRING, 0, -1 },
822 { flatbuffers::ET_BOOL, 0, -1 },
823 { flatbuffers::ET_UCHAR, 1, -1 },
824 { flatbuffers::ET_CHAR, 0, 1 },
825 { flatbuffers::ET_SEQUENCE, 1, 2 },
826 { flatbuffers::ET_UTYPE, 0, 3 },
827 { flatbuffers::ET_SEQUENCE, 0, 3 },
828 { flatbuffers::ET_SEQUENCE, 1, 0 }
829 };
830 static const flatbuffers::TypeFunction type_refs[] = {
831 MyGame::Sample::Vec3TypeTable,
832 MyGame::Sample::ColorTypeTable,
833 MyGame::Sample::WeaponTypeTable,
834 MyGame::Sample::EquipmentTypeTable
835 };
836 static const char * const names[] = {
837 "pos",
838 "mana",
839 "hp",
840 "name",
841 "friendly",
842 "inventory",
843 "color",
844 "weapons",
845 "equipped_type",
846 "equipped",
847 "path"
848 };
849 static const flatbuffers::TypeTable tt = {
850 flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, nullptr, names
851 };
852 return &tt;
853 }
854
855 inline const flatbuffers::TypeTable *WeaponTypeTable() {
856 static const flatbuffers::TypeCode type_codes[] = {
857 { flatbuffers::ET_STRING, 0, -1 },
858 { flatbuffers::ET_SHORT, 0, -1 }
859 };
860 static const char * const names[] = {
861 "name",
862 "damage"
863 };
864 static const flatbuffers::TypeTable tt = {
865 flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
866 };
867 return &tt;
868 }
869
870 inline const MyGame::Sample::Monster *GetMonster(const void *buf) {
871 return flatbuffers::GetRoot<MyGame::Sample::Monster>(buf);
872 }
873
874 inline const MyGame::Sample::Monster *GetSizePrefixedMonster(const void *buf) {
875 return flatbuffers::GetSizePrefixedRoot<MyGame::Sample::Monster>(buf);
876 }
877
878 inline Monster *GetMutableMonster(void *buf) {
879 return flatbuffers::GetMutableRoot<Monster>(buf);
880 }
881
882 inline MyGame::Sample::Monster *GetMutableSizePrefixedMonster(void *buf) {
883 return flatbuffers::GetMutableSizePrefixedRoot<MyGame::Sample::Monster>(buf);
884 }
885
886 inline bool VerifyMonsterBuffer(
887 flatbuffers::Verifier &verifier) {
888 return verifier.VerifyBuffer<MyGame::Sample::Monster>(nullptr);
889 }
890
891 inline bool VerifySizePrefixedMonsterBuffer(
892 flatbuffers::Verifier &verifier) {
893 return verifier.VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr);
894 }
895
896 inline void FinishMonsterBuffer(
897 flatbuffers::FlatBufferBuilder &fbb,
898 flatbuffers::Offset<MyGame::Sample::Monster> root) {
899 fbb.Finish(root);
900 }
901
902 inline void FinishSizePrefixedMonsterBuffer(
903 flatbuffers::FlatBufferBuilder &fbb,
904 flatbuffers::Offset<MyGame::Sample::Monster> root) {
905 fbb.FinishSizePrefixed(root);
906 }
907
908 inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackMonster(
909 const void *buf,
910 const flatbuffers::resolver_function_t *res = nullptr) {
911 return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetMonster(buf)->UnPack(res));
912 }
913
914 inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackSizePrefixedMonster(
915 const void *buf,
916 const flatbuffers::resolver_function_t *res = nullptr) {
917 return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetSizePrefixedMonster(buf)->UnPack(res));
918 }
919
920 } // namespace Sample
921 } // namespace MyGame
922
923 #endif // FLATBUFFERS_GENERATED_MONSTER_MYGAME_SAMPLE_H_
924