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 9 namespace MyGame { 10 namespace Example2 { 11 12 struct Monster; 13 struct MonsterT; 14 15 } // namespace Example2 16 17 namespace Example { 18 19 struct Test; 20 21 struct TestSimpleTableWithEnum; 22 struct TestSimpleTableWithEnumT; 23 24 struct Vec3; 25 26 struct Stat; 27 struct StatT; 28 29 struct Monster; 30 struct MonsterT; 31 32 enum Color { 33 Color_Red = 1, 34 Color_Green = 2, 35 Color_Blue = 8, 36 Color_NONE = 0, 37 Color_ANY = 11 38 }; 39 40 inline const char **EnumNamesColor() { 41 static const char *names[] = { 42 "Red", 43 "Green", 44 "", 45 "", 46 "", 47 "", 48 "", 49 "Blue", 50 nullptr 51 }; 52 return names; 53 } 54 55 inline const char *EnumNameColor(Color e) { 56 const size_t index = static_cast<int>(e) - static_cast<int>(Color_Red); 57 return EnumNamesColor()[index]; 58 } 59 60 enum Any { 61 Any_NONE = 0, 62 Any_Monster = 1, 63 Any_TestSimpleTableWithEnum = 2, 64 Any_MyGame_Example2_Monster = 3, 65 Any_MIN = Any_NONE, 66 Any_MAX = Any_MyGame_Example2_Monster 67 }; 68 69 inline const char **EnumNamesAny() { 70 static const char *names[] = { 71 "NONE", 72 "Monster", 73 "TestSimpleTableWithEnum", 74 "MyGame_Example2_Monster", 75 nullptr 76 }; 77 return names; 78 } 79 80 inline const char *EnumNameAny(Any e) { 81 const size_t index = static_cast<int>(e); 82 return EnumNamesAny()[index]; 83 } 84 85 template<typename T> struct AnyTraits { 86 static const Any enum_value = Any_NONE; 87 }; 88 89 template<> struct AnyTraits<Monster> { 90 static const Any enum_value = Any_Monster; 91 }; 92 93 template<> struct AnyTraits<TestSimpleTableWithEnum> { 94 static const Any enum_value = Any_TestSimpleTableWithEnum; 95 }; 96 97 template<> struct AnyTraits<MyGame::Example2::Monster> { 98 static const Any enum_value = Any_MyGame_Example2_Monster; 99 }; 100 101 struct AnyUnion { 102 Any type; 103 flatbuffers::NativeTable *table; 104 105 AnyUnion() : type(Any_NONE), table(nullptr) {} 106 AnyUnion(AnyUnion&& u): 107 type(std::move(u.type)), table(std::move(u.table)) {} 108 AnyUnion(const AnyUnion &); 109 AnyUnion &operator=(const AnyUnion &); 110 ~AnyUnion() { Reset(); } 111 112 void Reset(); 113 114 template <typename T> 115 void Set(T&& value) { 116 Reset(); 117 type = AnyTraits<typename T::TableType>::enum_value; 118 if (type != Any_NONE) { 119 table = new T(std::forward<T>(value)); 120 } 121 } 122 123 static flatbuffers::NativeTable *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); 124 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 125 126 MonsterT *AsMonster() { 127 return type == Any_Monster ? 128 reinterpret_cast<MonsterT *>(table) : nullptr; 129 } 130 TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { 131 return type == Any_TestSimpleTableWithEnum ? 132 reinterpret_cast<TestSimpleTableWithEnumT *>(table) : nullptr; 133 } 134 MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { 135 return type == Any_MyGame_Example2_Monster ? 136 reinterpret_cast<MyGame::Example2::MonsterT *>(table) : nullptr; 137 } 138 }; 139 140 bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); 141 bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 142 143 MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { 144 private: 145 int16_t a_; 146 int8_t b_; 147 int8_t padding0__; 148 149 public: 150 Test() { 151 memset(this, 0, sizeof(Test)); 152 } 153 Test(const Test &_o) { 154 memcpy(this, &_o, sizeof(Test)); 155 } 156 Test(int16_t _a, int8_t _b) 157 : a_(flatbuffers::EndianScalar(_a)), 158 b_(flatbuffers::EndianScalar(_b)), 159 padding0__(0) { 160 (void)padding0__; 161 } 162 int16_t a() const { 163 return flatbuffers::EndianScalar(a_); 164 } 165 void mutate_a(int16_t _a) { 166 flatbuffers::WriteScalar(&a_, _a); 167 } 168 int8_t b() const { 169 return flatbuffers::EndianScalar(b_); 170 } 171 void mutate_b(int8_t _b) { 172 flatbuffers::WriteScalar(&b_, _b); 173 } 174 }; 175 STRUCT_END(Test, 4); 176 177 MANUALLY_ALIGNED_STRUCT(16) Vec3 FLATBUFFERS_FINAL_CLASS { 178 private: 179 float x_; 180 float y_; 181 float z_; 182 int32_t padding0__; 183 double test1_; 184 int8_t test2_; 185 int8_t padding1__; 186 Test test3_; 187 int16_t padding2__; 188 189 public: 190 Vec3() { 191 memset(this, 0, sizeof(Vec3)); 192 } 193 Vec3(const Vec3 &_o) { 194 memcpy(this, &_o, sizeof(Vec3)); 195 } 196 Vec3(float _x, float _y, float _z, double _test1, Color _test2, const Test &_test3) 197 : x_(flatbuffers::EndianScalar(_x)), 198 y_(flatbuffers::EndianScalar(_y)), 199 z_(flatbuffers::EndianScalar(_z)), 200 padding0__(0), 201 test1_(flatbuffers::EndianScalar(_test1)), 202 test2_(flatbuffers::EndianScalar(static_cast<int8_t>(_test2))), 203 padding1__(0), 204 test3_(_test3), 205 padding2__(0) { 206 (void)padding0__; 207 (void)padding1__; 208 (void)padding2__; 209 } 210 float x() const { 211 return flatbuffers::EndianScalar(x_); 212 } 213 void mutate_x(float _x) { 214 flatbuffers::WriteScalar(&x_, _x); 215 } 216 float y() const { 217 return flatbuffers::EndianScalar(y_); 218 } 219 void mutate_y(float _y) { 220 flatbuffers::WriteScalar(&y_, _y); 221 } 222 float z() const { 223 return flatbuffers::EndianScalar(z_); 224 } 225 void mutate_z(float _z) { 226 flatbuffers::WriteScalar(&z_, _z); 227 } 228 double test1() const { 229 return flatbuffers::EndianScalar(test1_); 230 } 231 void mutate_test1(double _test1) { 232 flatbuffers::WriteScalar(&test1_, _test1); 233 } 234 Color test2() const { 235 return static_cast<Color>(flatbuffers::EndianScalar(test2_)); 236 } 237 void mutate_test2(Color _test2) { 238 flatbuffers::WriteScalar(&test2_, static_cast<int8_t>(_test2)); 239 } 240 const Test &test3() const { 241 return test3_; 242 } 243 const Test &mutable_test3() { 244 return test3_; 245 } 246 }; 247 STRUCT_END(Vec3, 32); 248 249 } // namespace Example 250 251 namespace Example2 { 252 253 struct MonsterT : public flatbuffers::NativeTable { 254 typedef Monster TableType; 255 MonsterT() { 256 } 257 }; 258 259 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 260 typedef MonsterT NativeTableType; 261 bool Verify(flatbuffers::Verifier &verifier) const { 262 return VerifyTableStart(verifier) && 263 verifier.EndTable(); 264 } 265 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 266 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 267 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 268 }; 269 270 struct MonsterBuilder { 271 flatbuffers::FlatBufferBuilder &fbb_; 272 flatbuffers::uoffset_t start_; 273 MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) 274 : fbb_(_fbb) { 275 start_ = fbb_.StartTable(); 276 } 277 MonsterBuilder &operator=(const MonsterBuilder &); 278 flatbuffers::Offset<Monster> Finish() { 279 const auto end = fbb_.EndTable(start_, 0); 280 auto o = flatbuffers::Offset<Monster>(end); 281 return o; 282 } 283 }; 284 285 inline flatbuffers::Offset<Monster> CreateMonster( 286 flatbuffers::FlatBufferBuilder &_fbb) { 287 MonsterBuilder builder_(_fbb); 288 return builder_.Finish(); 289 } 290 291 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 292 293 } // namespace Example2 294 295 namespace Example { 296 297 struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { 298 typedef TestSimpleTableWithEnum TableType; 299 Color color; 300 TestSimpleTableWithEnumT() 301 : color(Color_Green) { 302 } 303 }; 304 305 struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 306 typedef TestSimpleTableWithEnumT NativeTableType; 307 enum { 308 VT_COLOR = 4 309 }; 310 Color color() const { 311 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 2)); 312 } 313 bool mutate_color(Color _color) { 314 return SetField(VT_COLOR, static_cast<int8_t>(_color)); 315 } 316 bool Verify(flatbuffers::Verifier &verifier) const { 317 return VerifyTableStart(verifier) && 318 VerifyField<int8_t>(verifier, VT_COLOR) && 319 verifier.EndTable(); 320 } 321 TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 322 void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 323 static flatbuffers::Offset<TestSimpleTableWithEnum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 324 }; 325 326 struct TestSimpleTableWithEnumBuilder { 327 flatbuffers::FlatBufferBuilder &fbb_; 328 flatbuffers::uoffset_t start_; 329 void add_color(Color color) { 330 fbb_.AddElement<int8_t>(TestSimpleTableWithEnum::VT_COLOR, static_cast<int8_t>(color), 2); 331 } 332 TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) 333 : fbb_(_fbb) { 334 start_ = fbb_.StartTable(); 335 } 336 TestSimpleTableWithEnumBuilder &operator=(const TestSimpleTableWithEnumBuilder &); 337 flatbuffers::Offset<TestSimpleTableWithEnum> Finish() { 338 const auto end = fbb_.EndTable(start_, 1); 339 auto o = flatbuffers::Offset<TestSimpleTableWithEnum>(end); 340 return o; 341 } 342 }; 343 344 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum( 345 flatbuffers::FlatBufferBuilder &_fbb, 346 Color color = Color_Green) { 347 TestSimpleTableWithEnumBuilder builder_(_fbb); 348 builder_.add_color(color); 349 return builder_.Finish(); 350 } 351 352 flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 353 354 struct StatT : public flatbuffers::NativeTable { 355 typedef Stat TableType; 356 std::string id; 357 int64_t val; 358 uint16_t count; 359 StatT() 360 : val(0), 361 count(0) { 362 } 363 }; 364 365 struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 366 typedef StatT NativeTableType; 367 enum { 368 VT_ID = 4, 369 VT_VAL = 6, 370 VT_COUNT = 8 371 }; 372 const flatbuffers::String *id() const { 373 return GetPointer<const flatbuffers::String *>(VT_ID); 374 } 375 flatbuffers::String *mutable_id() { 376 return GetPointer<flatbuffers::String *>(VT_ID); 377 } 378 int64_t val() const { 379 return GetField<int64_t>(VT_VAL, 0); 380 } 381 bool mutate_val(int64_t _val) { 382 return SetField(VT_VAL, _val); 383 } 384 uint16_t count() const { 385 return GetField<uint16_t>(VT_COUNT, 0); 386 } 387 bool mutate_count(uint16_t _count) { 388 return SetField(VT_COUNT, _count); 389 } 390 bool Verify(flatbuffers::Verifier &verifier) const { 391 return VerifyTableStart(verifier) && 392 VerifyField<flatbuffers::uoffset_t>(verifier, VT_ID) && 393 verifier.Verify(id()) && 394 VerifyField<int64_t>(verifier, VT_VAL) && 395 VerifyField<uint16_t>(verifier, VT_COUNT) && 396 verifier.EndTable(); 397 } 398 StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 399 void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 400 static flatbuffers::Offset<Stat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 401 }; 402 403 struct StatBuilder { 404 flatbuffers::FlatBufferBuilder &fbb_; 405 flatbuffers::uoffset_t start_; 406 void add_id(flatbuffers::Offset<flatbuffers::String> id) { 407 fbb_.AddOffset(Stat::VT_ID, id); 408 } 409 void add_val(int64_t val) { 410 fbb_.AddElement<int64_t>(Stat::VT_VAL, val, 0); 411 } 412 void add_count(uint16_t count) { 413 fbb_.AddElement<uint16_t>(Stat::VT_COUNT, count, 0); 414 } 415 StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) 416 : fbb_(_fbb) { 417 start_ = fbb_.StartTable(); 418 } 419 StatBuilder &operator=(const StatBuilder &); 420 flatbuffers::Offset<Stat> Finish() { 421 const auto end = fbb_.EndTable(start_, 3); 422 auto o = flatbuffers::Offset<Stat>(end); 423 return o; 424 } 425 }; 426 427 inline flatbuffers::Offset<Stat> CreateStat( 428 flatbuffers::FlatBufferBuilder &_fbb, 429 flatbuffers::Offset<flatbuffers::String> id = 0, 430 int64_t val = 0, 431 uint16_t count = 0) { 432 StatBuilder builder_(_fbb); 433 builder_.add_val(val); 434 builder_.add_id(id); 435 builder_.add_count(count); 436 return builder_.Finish(); 437 } 438 439 inline flatbuffers::Offset<Stat> CreateStatDirect( 440 flatbuffers::FlatBufferBuilder &_fbb, 441 const char *id = nullptr, 442 int64_t val = 0, 443 uint16_t count = 0) { 444 return MyGame::Example::CreateStat( 445 _fbb, 446 id ? _fbb.CreateString(id) : 0, 447 val, 448 count); 449 } 450 451 flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 452 453 struct MonsterT : public flatbuffers::NativeTable { 454 typedef Monster TableType; 455 std::unique_ptr<Vec3> pos; 456 int16_t mana; 457 int16_t hp; 458 std::string name; 459 std::vector<uint8_t> inventory; 460 Color color; 461 AnyUnion test; 462 std::vector<Test> test4; 463 std::vector<std::string> testarrayofstring; 464 std::vector<std::unique_ptr<MonsterT>> testarrayoftables; 465 std::unique_ptr<MonsterT> enemy; 466 std::vector<uint8_t> testnestedflatbuffer; 467 std::unique_ptr<StatT> testempty; 468 bool testbool; 469 int32_t testhashs32_fnv1; 470 uint32_t testhashu32_fnv1; 471 int64_t testhashs64_fnv1; 472 uint64_t testhashu64_fnv1; 473 int32_t testhashs32_fnv1a; 474 Stat *testhashu32_fnv1a; 475 int64_t testhashs64_fnv1a; 476 uint64_t testhashu64_fnv1a; 477 std::vector<bool> testarrayofbools; 478 float testf; 479 float testf2; 480 float testf3; 481 std::vector<std::string> testarrayofstring2; 482 MonsterT() 483 : mana(150), 484 hp(100), 485 color(Color_Blue), 486 testbool(false), 487 testhashs32_fnv1(0), 488 testhashu32_fnv1(0), 489 testhashs64_fnv1(0), 490 testhashu64_fnv1(0), 491 testhashs32_fnv1a(0), 492 testhashu32_fnv1a(0), 493 testhashs64_fnv1a(0), 494 testhashu64_fnv1a(0), 495 testf(3.14159f), 496 testf2(3.0f), 497 testf3(0.0f) { 498 } 499 }; 500 501 /// an example documentation comment: monster object 502 struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 503 typedef MonsterT NativeTableType; 504 enum { 505 VT_POS = 4, 506 VT_MANA = 6, 507 VT_HP = 8, 508 VT_NAME = 10, 509 VT_INVENTORY = 14, 510 VT_COLOR = 16, 511 VT_TEST_TYPE = 18, 512 VT_TEST = 20, 513 VT_TEST4 = 22, 514 VT_TESTARRAYOFSTRING = 24, 515 VT_TESTARRAYOFTABLES = 26, 516 VT_ENEMY = 28, 517 VT_TESTNESTEDFLATBUFFER = 30, 518 VT_TESTEMPTY = 32, 519 VT_TESTBOOL = 34, 520 VT_TESTHASHS32_FNV1 = 36, 521 VT_TESTHASHU32_FNV1 = 38, 522 VT_TESTHASHS64_FNV1 = 40, 523 VT_TESTHASHU64_FNV1 = 42, 524 VT_TESTHASHS32_FNV1A = 44, 525 VT_TESTHASHU32_FNV1A = 46, 526 VT_TESTHASHS64_FNV1A = 48, 527 VT_TESTHASHU64_FNV1A = 50, 528 VT_TESTARRAYOFBOOLS = 52, 529 VT_TESTF = 54, 530 VT_TESTF2 = 56, 531 VT_TESTF3 = 58, 532 VT_TESTARRAYOFSTRING2 = 60 533 }; 534 const Vec3 *pos() const { 535 return GetStruct<const Vec3 *>(VT_POS); 536 } 537 Vec3 *mutable_pos() { 538 return GetStruct<Vec3 *>(VT_POS); 539 } 540 int16_t mana() const { 541 return GetField<int16_t>(VT_MANA, 150); 542 } 543 bool mutate_mana(int16_t _mana) { 544 return SetField(VT_MANA, _mana); 545 } 546 int16_t hp() const { 547 return GetField<int16_t>(VT_HP, 100); 548 } 549 bool mutate_hp(int16_t _hp) { 550 return SetField(VT_HP, _hp); 551 } 552 const flatbuffers::String *name() const { 553 return GetPointer<const flatbuffers::String *>(VT_NAME); 554 } 555 flatbuffers::String *mutable_name() { 556 return GetPointer<flatbuffers::String *>(VT_NAME); 557 } 558 bool KeyCompareLessThan(const Monster *o) const { 559 return *name() < *o->name(); 560 } 561 int KeyCompareWithValue(const char *val) const { 562 return strcmp(name()->c_str(), val); 563 } 564 const flatbuffers::Vector<uint8_t> *inventory() const { 565 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); 566 } 567 flatbuffers::Vector<uint8_t> *mutable_inventory() { 568 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); 569 } 570 Color color() const { 571 return static_cast<Color>(GetField<int8_t>(VT_COLOR, 8)); 572 } 573 bool mutate_color(Color _color) { 574 return SetField(VT_COLOR, static_cast<int8_t>(_color)); 575 } 576 Any test_type() const { 577 return static_cast<Any>(GetField<uint8_t>(VT_TEST_TYPE, 0)); 578 } 579 bool mutate_test_type(Any _test_type) { 580 return SetField(VT_TEST_TYPE, static_cast<uint8_t>(_test_type)); 581 } 582 const void *test() const { 583 return GetPointer<const void *>(VT_TEST); 584 } 585 void *mutable_test() { 586 return GetPointer<void *>(VT_TEST); 587 } 588 const flatbuffers::Vector<const Test *> *test4() const { 589 return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST4); 590 } 591 flatbuffers::Vector<const Test *> *mutable_test4() { 592 return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST4); 593 } 594 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring() const { 595 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING); 596 } 597 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring() { 598 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING); 599 } 600 /// an example documentation comment: this will end up in the generated code 601 /// multiline too 602 const flatbuffers::Vector<flatbuffers::Offset<Monster>> *testarrayoftables() const { 603 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES); 604 } 605 flatbuffers::Vector<flatbuffers::Offset<Monster>> *mutable_testarrayoftables() { 606 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES); 607 } 608 const Monster *enemy() const { 609 return GetPointer<const Monster *>(VT_ENEMY); 610 } 611 Monster *mutable_enemy() { 612 return GetPointer<Monster *>(VT_ENEMY); 613 } 614 const flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const { 615 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER); 616 } 617 flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() { 618 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER); 619 } 620 const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { 621 const uint8_t* data = testnestedflatbuffer()->Data(); 622 return flatbuffers::GetRoot<MyGame::Example::Monster>(data); 623 } 624 const Stat *testempty() const { 625 return GetPointer<const Stat *>(VT_TESTEMPTY); 626 } 627 Stat *mutable_testempty() { 628 return GetPointer<Stat *>(VT_TESTEMPTY); 629 } 630 bool testbool() const { 631 return GetField<uint8_t>(VT_TESTBOOL, 0) != 0; 632 } 633 bool mutate_testbool(bool _testbool) { 634 return SetField(VT_TESTBOOL, static_cast<uint8_t>(_testbool)); 635 } 636 int32_t testhashs32_fnv1() const { 637 return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0); 638 } 639 bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) { 640 return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1); 641 } 642 uint32_t testhashu32_fnv1() const { 643 return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0); 644 } 645 bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) { 646 return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1); 647 } 648 int64_t testhashs64_fnv1() const { 649 return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0); 650 } 651 bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) { 652 return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1); 653 } 654 uint64_t testhashu64_fnv1() const { 655 return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0); 656 } 657 bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) { 658 return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1); 659 } 660 int32_t testhashs32_fnv1a() const { 661 return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0); 662 } 663 bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) { 664 return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a); 665 } 666 uint32_t testhashu32_fnv1a() const { 667 return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0); 668 } 669 bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) { 670 return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a); 671 } 672 int64_t testhashs64_fnv1a() const { 673 return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0); 674 } 675 bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) { 676 return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a); 677 } 678 uint64_t testhashu64_fnv1a() const { 679 return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0); 680 } 681 bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) { 682 return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a); 683 } 684 const flatbuffers::Vector<uint8_t> *testarrayofbools() const { 685 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS); 686 } 687 flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() { 688 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS); 689 } 690 float testf() const { 691 return GetField<float>(VT_TESTF, 3.14159f); 692 } 693 bool mutate_testf(float _testf) { 694 return SetField(VT_TESTF, _testf); 695 } 696 float testf2() const { 697 return GetField<float>(VT_TESTF2, 3.0f); 698 } 699 bool mutate_testf2(float _testf2) { 700 return SetField(VT_TESTF2, _testf2); 701 } 702 float testf3() const { 703 return GetField<float>(VT_TESTF3, 0.0f); 704 } 705 bool mutate_testf3(float _testf3) { 706 return SetField(VT_TESTF3, _testf3); 707 } 708 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2() const { 709 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2); 710 } 711 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring2() { 712 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2); 713 } 714 bool Verify(flatbuffers::Verifier &verifier) const { 715 return VerifyTableStart(verifier) && 716 VerifyField<Vec3>(verifier, VT_POS) && 717 VerifyField<int16_t>(verifier, VT_MANA) && 718 VerifyField<int16_t>(verifier, VT_HP) && 719 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NAME) && 720 verifier.Verify(name()) && 721 VerifyField<flatbuffers::uoffset_t>(verifier, VT_INVENTORY) && 722 verifier.Verify(inventory()) && 723 VerifyField<int8_t>(verifier, VT_COLOR) && 724 VerifyField<uint8_t>(verifier, VT_TEST_TYPE) && 725 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TEST) && 726 VerifyAny(verifier, test(), test_type()) && 727 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TEST4) && 728 verifier.Verify(test4()) && 729 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTARRAYOFSTRING) && 730 verifier.Verify(testarrayofstring()) && 731 verifier.VerifyVectorOfStrings(testarrayofstring()) && 732 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTARRAYOFTABLES) && 733 verifier.Verify(testarrayoftables()) && 734 verifier.VerifyVectorOfTables(testarrayoftables()) && 735 VerifyField<flatbuffers::uoffset_t>(verifier, VT_ENEMY) && 736 verifier.VerifyTable(enemy()) && 737 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTNESTEDFLATBUFFER) && 738 verifier.Verify(testnestedflatbuffer()) && 739 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTEMPTY) && 740 verifier.VerifyTable(testempty()) && 741 VerifyField<uint8_t>(verifier, VT_TESTBOOL) && 742 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) && 743 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) && 744 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) && 745 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) && 746 VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) && 747 VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) && 748 VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) && 749 VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) && 750 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTARRAYOFBOOLS) && 751 verifier.Verify(testarrayofbools()) && 752 VerifyField<float>(verifier, VT_TESTF) && 753 VerifyField<float>(verifier, VT_TESTF2) && 754 VerifyField<float>(verifier, VT_TESTF3) && 755 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TESTARRAYOFSTRING2) && 756 verifier.Verify(testarrayofstring2()) && 757 verifier.VerifyVectorOfStrings(testarrayofstring2()) && 758 verifier.EndTable(); 759 } 760 MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 761 void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 762 static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 763 }; 764 765 struct MonsterBuilder { 766 flatbuffers::FlatBufferBuilder &fbb_; 767 flatbuffers::uoffset_t start_; 768 void add_pos(const Vec3 *pos) { 769 fbb_.AddStruct(Monster::VT_POS, pos); 770 } 771 void add_mana(int16_t mana) { 772 fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150); 773 } 774 void add_hp(int16_t hp) { 775 fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100); 776 } 777 void add_name(flatbuffers::Offset<flatbuffers::String> name) { 778 fbb_.AddOffset(Monster::VT_NAME, name); 779 } 780 void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { 781 fbb_.AddOffset(Monster::VT_INVENTORY, inventory); 782 } 783 void add_color(Color color) { 784 fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 8); 785 } 786 void add_test_type(Any test_type) { 787 fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0); 788 } 789 void add_test(flatbuffers::Offset<void> test) { 790 fbb_.AddOffset(Monster::VT_TEST, test); 791 } 792 void add_test4(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4) { 793 fbb_.AddOffset(Monster::VT_TEST4, test4); 794 } 795 void add_testarrayofstring(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring) { 796 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); 797 } 798 void add_testarrayoftables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables) { 799 fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); 800 } 801 void add_enemy(flatbuffers::Offset<Monster> enemy) { 802 fbb_.AddOffset(Monster::VT_ENEMY, enemy); 803 } 804 void add_testnestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer) { 805 fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); 806 } 807 void add_testempty(flatbuffers::Offset<Stat> testempty) { 808 fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty); 809 } 810 void add_testbool(bool testbool) { 811 fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0); 812 } 813 void add_testhashs32_fnv1(int32_t testhashs32_fnv1) { 814 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); 815 } 816 void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) { 817 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); 818 } 819 void add_testhashs64_fnv1(int64_t testhashs64_fnv1) { 820 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); 821 } 822 void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) { 823 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); 824 } 825 void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) { 826 fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); 827 } 828 void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) { 829 fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); 830 } 831 void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) { 832 fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); 833 } 834 void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) { 835 fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); 836 } 837 void add_testarrayofbools(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools) { 838 fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); 839 } 840 void add_testf(float testf) { 841 fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f); 842 } 843 void add_testf2(float testf2) { 844 fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f); 845 } 846 void add_testf3(float testf3) { 847 fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f); 848 } 849 void add_testarrayofstring2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2) { 850 fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); 851 } 852 MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) 853 : fbb_(_fbb) { 854 start_ = fbb_.StartTable(); 855 } 856 MonsterBuilder &operator=(const MonsterBuilder &); 857 flatbuffers::Offset<Monster> Finish() { 858 const auto end = fbb_.EndTable(start_, 29); 859 auto o = flatbuffers::Offset<Monster>(end); 860 fbb_.Required(o, Monster::VT_NAME); 861 return o; 862 } 863 }; 864 865 inline flatbuffers::Offset<Monster> CreateMonster( 866 flatbuffers::FlatBufferBuilder &_fbb, 867 const Vec3 *pos = 0, 868 int16_t mana = 150, 869 int16_t hp = 100, 870 flatbuffers::Offset<flatbuffers::String> name = 0, 871 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0, 872 Color color = Color_Blue, 873 Any test_type = Any_NONE, 874 flatbuffers::Offset<void> test = 0, 875 flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4 = 0, 876 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring = 0, 877 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables = 0, 878 flatbuffers::Offset<Monster> enemy = 0, 879 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0, 880 flatbuffers::Offset<Stat> testempty = 0, 881 bool testbool = false, 882 int32_t testhashs32_fnv1 = 0, 883 uint32_t testhashu32_fnv1 = 0, 884 int64_t testhashs64_fnv1 = 0, 885 uint64_t testhashu64_fnv1 = 0, 886 int32_t testhashs32_fnv1a = 0, 887 uint32_t testhashu32_fnv1a = 0, 888 int64_t testhashs64_fnv1a = 0, 889 uint64_t testhashu64_fnv1a = 0, 890 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools = 0, 891 float testf = 3.14159f, 892 float testf2 = 3.0f, 893 float testf3 = 0.0f, 894 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2 = 0) { 895 MonsterBuilder builder_(_fbb); 896 builder_.add_testhashu64_fnv1a(testhashu64_fnv1a); 897 builder_.add_testhashs64_fnv1a(testhashs64_fnv1a); 898 builder_.add_testhashu64_fnv1(testhashu64_fnv1); 899 builder_.add_testhashs64_fnv1(testhashs64_fnv1); 900 builder_.add_testarrayofstring2(testarrayofstring2); 901 builder_.add_testf3(testf3); 902 builder_.add_testf2(testf2); 903 builder_.add_testf(testf); 904 builder_.add_testarrayofbools(testarrayofbools); 905 builder_.add_testhashu32_fnv1a(testhashu32_fnv1a); 906 builder_.add_testhashs32_fnv1a(testhashs32_fnv1a); 907 builder_.add_testhashu32_fnv1(testhashu32_fnv1); 908 builder_.add_testhashs32_fnv1(testhashs32_fnv1); 909 builder_.add_testempty(testempty); 910 builder_.add_testnestedflatbuffer(testnestedflatbuffer); 911 builder_.add_enemy(enemy); 912 builder_.add_testarrayoftables(testarrayoftables); 913 builder_.add_testarrayofstring(testarrayofstring); 914 builder_.add_test4(test4); 915 builder_.add_test(test); 916 builder_.add_inventory(inventory); 917 builder_.add_name(name); 918 builder_.add_pos(pos); 919 builder_.add_hp(hp); 920 builder_.add_mana(mana); 921 builder_.add_testbool(testbool); 922 builder_.add_test_type(test_type); 923 builder_.add_color(color); 924 return builder_.Finish(); 925 } 926 927 inline flatbuffers::Offset<Monster> CreateMonsterDirect( 928 flatbuffers::FlatBufferBuilder &_fbb, 929 const Vec3 *pos = 0, 930 int16_t mana = 150, 931 int16_t hp = 100, 932 const char *name = nullptr, 933 const std::vector<uint8_t> *inventory = nullptr, 934 Color color = Color_Blue, 935 Any test_type = Any_NONE, 936 flatbuffers::Offset<void> test = 0, 937 const std::vector<const Test *> *test4 = nullptr, 938 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring = nullptr, 939 const std::vector<flatbuffers::Offset<Monster>> *testarrayoftables = nullptr, 940 flatbuffers::Offset<Monster> enemy = 0, 941 const std::vector<uint8_t> *testnestedflatbuffer = nullptr, 942 flatbuffers::Offset<Stat> testempty = 0, 943 bool testbool = false, 944 int32_t testhashs32_fnv1 = 0, 945 uint32_t testhashu32_fnv1 = 0, 946 int64_t testhashs64_fnv1 = 0, 947 uint64_t testhashu64_fnv1 = 0, 948 int32_t testhashs32_fnv1a = 0, 949 uint32_t testhashu32_fnv1a = 0, 950 int64_t testhashs64_fnv1a = 0, 951 uint64_t testhashu64_fnv1a = 0, 952 const std::vector<uint8_t> *testarrayofbools = nullptr, 953 float testf = 3.14159f, 954 float testf2 = 3.0f, 955 float testf3 = 0.0f, 956 const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2 = nullptr) { 957 return MyGame::Example::CreateMonster( 958 _fbb, 959 pos, 960 mana, 961 hp, 962 name ? _fbb.CreateString(name) : 0, 963 inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0, 964 color, 965 test_type, 966 test, 967 test4 ? _fbb.CreateVector<const Test *>(*test4) : 0, 968 testarrayofstring ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring) : 0, 969 testarrayoftables ? _fbb.CreateVector<flatbuffers::Offset<Monster>>(*testarrayoftables) : 0, 970 enemy, 971 testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0, 972 testempty, 973 testbool, 974 testhashs32_fnv1, 975 testhashu32_fnv1, 976 testhashs64_fnv1, 977 testhashu64_fnv1, 978 testhashs32_fnv1a, 979 testhashu32_fnv1a, 980 testhashs64_fnv1a, 981 testhashu64_fnv1a, 982 testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0, 983 testf, 984 testf2, 985 testf3, 986 testarrayofstring2 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring2) : 0); 987 } 988 989 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 990 991 } // namespace Example 992 993 namespace Example2 { 994 995 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 996 auto _o = new MonsterT(); 997 UnPackTo(_o, _resolver); 998 return _o; 999 } 1000 1001 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1002 (void)_o; 1003 (void)_resolver; 1004 } 1005 1006 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1007 return CreateMonster(_fbb, _o, _rehasher); 1008 } 1009 1010 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1011 (void)_rehasher; 1012 (void)_o; 1013 return MyGame::Example2::CreateMonster( 1014 _fbb); 1015 } 1016 1017 } // namespace Example2 1018 1019 namespace Example { 1020 1021 inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1022 auto _o = new TestSimpleTableWithEnumT(); 1023 UnPackTo(_o, _resolver); 1024 return _o; 1025 } 1026 1027 inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1028 (void)_o; 1029 (void)_resolver; 1030 { auto _e = color(); _o->color = _e; }; 1031 } 1032 1033 inline flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1034 return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); 1035 } 1036 1037 inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1038 (void)_rehasher; 1039 (void)_o; 1040 auto _color = _o->color; 1041 return MyGame::Example::CreateTestSimpleTableWithEnum( 1042 _fbb, 1043 _color); 1044 } 1045 1046 inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1047 auto _o = new StatT(); 1048 UnPackTo(_o, _resolver); 1049 return _o; 1050 } 1051 1052 inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1053 (void)_o; 1054 (void)_resolver; 1055 { auto _e = id(); if (_e) _o->id = _e->str(); }; 1056 { auto _e = val(); _o->val = _e; }; 1057 { auto _e = count(); _o->count = _e; }; 1058 } 1059 1060 inline flatbuffers::Offset<Stat> Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1061 return CreateStat(_fbb, _o, _rehasher); 1062 } 1063 1064 inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1065 (void)_rehasher; 1066 (void)_o; 1067 auto _id = _o->id.size() ? _fbb.CreateString(_o->id) : 0; 1068 auto _val = _o->val; 1069 auto _count = _o->count; 1070 return MyGame::Example::CreateStat( 1071 _fbb, 1072 _id, 1073 _val, 1074 _count); 1075 } 1076 1077 inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1078 auto _o = new MonsterT(); 1079 UnPackTo(_o, _resolver); 1080 return _o; 1081 } 1082 1083 inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1084 (void)_o; 1085 (void)_resolver; 1086 { auto _e = pos(); if (_e) _o->pos = std::unique_ptr<Vec3>(new Vec3(*_e)); }; 1087 { auto _e = mana(); _o->mana = _e; }; 1088 { auto _e = hp(); _o->hp = _e; }; 1089 { auto _e = name(); if (_e) _o->name = _e->str(); }; 1090 { auto _e = inventory(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory.push_back(_e->Get(_i)); } }; 1091 { auto _e = color(); _o->color = _e; }; 1092 { auto _e = test_type(); _o->test.type = _e; }; 1093 { auto _e = test(); if (_e) _o->test.table = AnyUnion::UnPack(_e, test_type(),_resolver); }; 1094 { auto _e = test4(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4.push_back(*_e->Get(_i)); } }; 1095 { auto _e = testarrayofstring(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring.push_back(_e->Get(_i)->str()); } }; 1096 { auto _e = testarrayoftables(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables.push_back(std::unique_ptr<MonsterT>(_e->Get(_i)->UnPack(_resolver))); } }; 1097 { auto _e = enemy(); if (_e) _o->enemy = std::unique_ptr<MonsterT>(_e->UnPack(_resolver)); }; 1098 { auto _e = testnestedflatbuffer(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer.push_back(_e->Get(_i)); } }; 1099 { auto _e = testempty(); if (_e) _o->testempty = std::unique_ptr<StatT>(_e->UnPack(_resolver)); }; 1100 { auto _e = testbool(); _o->testbool = _e; }; 1101 { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }; 1102 { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; }; 1103 { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; }; 1104 { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; }; 1105 { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; }; 1106 { auto _e = testhashu32_fnv1a(); if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->testhashu32_fnv1a), static_cast<flatbuffers::hash_value_t>(_e)); else _o->testhashu32_fnv1a = nullptr; }; 1107 { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; }; 1108 { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; }; 1109 { auto _e = testarrayofbools(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools.push_back(_e->Get(_i) != 0); } }; 1110 { auto _e = testf(); _o->testf = _e; }; 1111 { auto _e = testf2(); _o->testf2 = _e; }; 1112 { auto _e = testf3(); _o->testf3 = _e; }; 1113 { auto _e = testarrayofstring2(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2.push_back(_e->Get(_i)->str()); } }; 1114 } 1115 1116 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1117 return CreateMonster(_fbb, _o, _rehasher); 1118 } 1119 1120 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1121 (void)_rehasher; 1122 (void)_o; 1123 auto _pos = _o->pos ? _o->pos.get() : 0; 1124 auto _mana = _o->mana; 1125 auto _hp = _o->hp; 1126 auto _name = _fbb.CreateString(_o->name); 1127 auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; 1128 auto _color = _o->color; 1129 auto _test_type = _o->test.type; 1130 auto _test = _o->test.Pack(_fbb); 1131 auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0; 1132 auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0; 1133 auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<flatbuffers::Offset<Monster>>(_o->testarrayoftables.size(), [&](size_t i) { return CreateMonster(_fbb, _o->testarrayoftables[i].get(), _rehasher); }) : 0; 1134 auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0; 1135 auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0; 1136 auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0; 1137 auto _testbool = _o->testbool; 1138 auto _testhashs32_fnv1 = _o->testhashs32_fnv1; 1139 auto _testhashu32_fnv1 = _o->testhashu32_fnv1; 1140 auto _testhashs64_fnv1 = _o->testhashs64_fnv1; 1141 auto _testhashu64_fnv1 = _o->testhashu64_fnv1; 1142 auto _testhashs32_fnv1a = _o->testhashs32_fnv1a; 1143 auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0; 1144 auto _testhashs64_fnv1a = _o->testhashs64_fnv1a; 1145 auto _testhashu64_fnv1a = _o->testhashu64_fnv1a; 1146 auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0; 1147 auto _testf = _o->testf; 1148 auto _testf2 = _o->testf2; 1149 auto _testf3 = _o->testf3; 1150 auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0; 1151 return MyGame::Example::CreateMonster( 1152 _fbb, 1153 _pos, 1154 _mana, 1155 _hp, 1156 _name, 1157 _inventory, 1158 _color, 1159 _test_type, 1160 _test, 1161 _test4, 1162 _testarrayofstring, 1163 _testarrayoftables, 1164 _enemy, 1165 _testnestedflatbuffer, 1166 _testempty, 1167 _testbool, 1168 _testhashs32_fnv1, 1169 _testhashu32_fnv1, 1170 _testhashs64_fnv1, 1171 _testhashu64_fnv1, 1172 _testhashs32_fnv1a, 1173 _testhashu32_fnv1a, 1174 _testhashs64_fnv1a, 1175 _testhashu64_fnv1a, 1176 _testarrayofbools, 1177 _testf, 1178 _testf2, 1179 _testf3, 1180 _testarrayofstring2); 1181 } 1182 1183 inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { 1184 switch (type) { 1185 case Any_NONE: { 1186 return true; 1187 } 1188 case Any_Monster: { 1189 auto ptr = reinterpret_cast<const Monster *>(obj); 1190 return verifier.VerifyTable(ptr); 1191 } 1192 case Any_TestSimpleTableWithEnum: { 1193 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 1194 return verifier.VerifyTable(ptr); 1195 } 1196 case Any_MyGame_Example2_Monster: { 1197 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 1198 return verifier.VerifyTable(ptr); 1199 } 1200 default: return false; 1201 } 1202 } 1203 1204 inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 1205 if (values->size() != types->size()) return false; 1206 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 1207 if (!VerifyAny( 1208 verifier, values->Get(i), types->GetEnum<Any>(i))) { 1209 return false; 1210 } 1211 } 1212 return true; 1213 } 1214 1215 inline flatbuffers::NativeTable *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { 1216 switch (type) { 1217 case Any_Monster: { 1218 auto ptr = reinterpret_cast<const Monster *>(obj); 1219 return ptr->UnPack(resolver); 1220 } 1221 case Any_TestSimpleTableWithEnum: { 1222 auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); 1223 return ptr->UnPack(resolver); 1224 } 1225 case Any_MyGame_Example2_Monster: { 1226 auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj); 1227 return ptr->UnPack(resolver); 1228 } 1229 default: return nullptr; 1230 } 1231 } 1232 1233 inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 1234 switch (type) { 1235 case Any_Monster: { 1236 auto ptr = reinterpret_cast<const MonsterT *>(table); 1237 return CreateMonster(_fbb, ptr, _rehasher).Union(); 1238 } 1239 case Any_TestSimpleTableWithEnum: { 1240 auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(table); 1241 return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); 1242 } 1243 case Any_MyGame_Example2_Monster: { 1244 auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(table); 1245 return CreateMonster(_fbb, ptr, _rehasher).Union(); 1246 } 1247 default: return 0; 1248 } 1249 } 1250 1251 inline void AnyUnion::Reset() { 1252 switch (type) { 1253 case Any_Monster: { 1254 auto ptr = reinterpret_cast<MonsterT *>(table); 1255 delete ptr; 1256 break; 1257 } 1258 case Any_TestSimpleTableWithEnum: { 1259 auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(table); 1260 delete ptr; 1261 break; 1262 } 1263 case Any_MyGame_Example2_Monster: { 1264 auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(table); 1265 delete ptr; 1266 break; 1267 } 1268 default: break; 1269 } 1270 table = nullptr; 1271 type = Any_NONE; 1272 } 1273 1274 inline const MyGame::Example::Monster *GetMonster(const void *buf) { 1275 return flatbuffers::GetRoot<MyGame::Example::Monster>(buf); 1276 } 1277 1278 inline Monster *GetMutableMonster(void *buf) { 1279 return flatbuffers::GetMutableRoot<Monster>(buf); 1280 } 1281 1282 inline const char *MonsterIdentifier() { 1283 return "MONS"; 1284 } 1285 1286 inline bool MonsterBufferHasIdentifier(const void *buf) { 1287 return flatbuffers::BufferHasIdentifier( 1288 buf, MonsterIdentifier()); 1289 } 1290 1291 inline bool VerifyMonsterBuffer( 1292 flatbuffers::Verifier &verifier) { 1293 return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier()); 1294 } 1295 1296 inline const char *MonsterExtension() { 1297 return "mon"; 1298 } 1299 1300 inline void FinishMonsterBuffer( 1301 flatbuffers::FlatBufferBuilder &fbb, 1302 flatbuffers::Offset<MyGame::Example::Monster> root) { 1303 fbb.Finish(root, MonsterIdentifier()); 1304 } 1305 1306 inline std::unique_ptr<MonsterT> UnPackMonster( 1307 const void *buf, 1308 const flatbuffers::resolver_function_t *res = nullptr) { 1309 return std::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res)); 1310 } 1311 1312 } // namespace Example 1313 } // namespace MyGame 1314 1315 #endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ 1316
