mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
8b92122f33
Zero offsets are non-sensical in FlatBuffers (since offsets are relative to themselves) but were allowed by the verifier. This could cause buffers made up of all zeroes to be interpreted as correct buffers with an empty root object. Generally, not allowing such offsets will make the verifier more likely to catch problems earlier. Change-Id: I54010bea29721b326ff8e5348fcd9fe78e5e7506 Tested: on Linux.
1421 lines
50 KiB
C++
1421 lines
50 KiB
C++
// automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
|
|
#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
|
|
#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
|
|
|
|
#include "flatbuffers/flatbuffers.h"
|
|
|
|
namespace MyGame {
|
|
namespace Example2 {
|
|
|
|
struct Monster;
|
|
struct MonsterT;
|
|
|
|
} // namespace Example2
|
|
|
|
namespace Example {
|
|
|
|
struct Test;
|
|
|
|
struct TestSimpleTableWithEnum;
|
|
struct TestSimpleTableWithEnumT;
|
|
|
|
struct Vec3;
|
|
|
|
struct Ability;
|
|
|
|
struct Stat;
|
|
struct StatT;
|
|
|
|
struct Monster;
|
|
struct MonsterT;
|
|
|
|
enum Color {
|
|
Color_Red = 1,
|
|
Color_Green = 2,
|
|
Color_Blue = 8,
|
|
Color_NONE = 0,
|
|
Color_ANY = 11
|
|
};
|
|
|
|
inline const char **EnumNamesColor() {
|
|
static const char *names[] = {
|
|
"Red",
|
|
"Green",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"Blue",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameColor(Color e) {
|
|
const size_t index = static_cast<int>(e) - static_cast<int>(Color_Red);
|
|
return EnumNamesColor()[index];
|
|
}
|
|
|
|
enum Any {
|
|
Any_NONE = 0,
|
|
Any_Monster = 1,
|
|
Any_TestSimpleTableWithEnum = 2,
|
|
Any_MyGame_Example2_Monster = 3,
|
|
Any_MIN = Any_NONE,
|
|
Any_MAX = Any_MyGame_Example2_Monster
|
|
};
|
|
|
|
inline const char **EnumNamesAny() {
|
|
static const char *names[] = {
|
|
"NONE",
|
|
"Monster",
|
|
"TestSimpleTableWithEnum",
|
|
"MyGame_Example2_Monster",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameAny(Any e) {
|
|
const size_t index = static_cast<int>(e);
|
|
return EnumNamesAny()[index];
|
|
}
|
|
|
|
template<typename T> struct AnyTraits {
|
|
static const Any enum_value = Any_NONE;
|
|
};
|
|
|
|
template<> struct AnyTraits<Monster> {
|
|
static const Any enum_value = Any_Monster;
|
|
};
|
|
|
|
template<> struct AnyTraits<TestSimpleTableWithEnum> {
|
|
static const Any enum_value = Any_TestSimpleTableWithEnum;
|
|
};
|
|
|
|
template<> struct AnyTraits<MyGame::Example2::Monster> {
|
|
static const Any enum_value = Any_MyGame_Example2_Monster;
|
|
};
|
|
|
|
struct AnyUnion {
|
|
Any type;
|
|
void *value;
|
|
|
|
AnyUnion() : type(Any_NONE), value(nullptr) {}
|
|
AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT :
|
|
type(Any_NONE), value(nullptr)
|
|
{ std::swap(type, u.type); std::swap(value, u.value); }
|
|
AnyUnion(const AnyUnion &) FLATBUFFERS_NOEXCEPT;
|
|
AnyUnion &operator=(const AnyUnion &u) FLATBUFFERS_NOEXCEPT
|
|
{ AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
|
|
AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT
|
|
{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
|
|
~AnyUnion() { Reset(); }
|
|
|
|
void Reset();
|
|
|
|
template <typename T>
|
|
void Set(T&& val) {
|
|
Reset();
|
|
type = AnyTraits<typename T::TableType>::enum_value;
|
|
if (type != Any_NONE) {
|
|
value = new T(std::forward<T>(val));
|
|
}
|
|
}
|
|
|
|
static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver);
|
|
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
|
|
|
|
MonsterT *AsMonster() {
|
|
return type == Any_Monster ?
|
|
reinterpret_cast<MonsterT *>(value) : nullptr;
|
|
}
|
|
TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() {
|
|
return type == Any_TestSimpleTableWithEnum ?
|
|
reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
|
|
}
|
|
MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() {
|
|
return type == Any_MyGame_Example2_Monster ?
|
|
reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
|
|
}
|
|
};
|
|
|
|
bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type);
|
|
bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
|
|
|
|
MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
|
|
private:
|
|
int16_t a_;
|
|
int8_t b_;
|
|
int8_t padding0__;
|
|
|
|
public:
|
|
Test() {
|
|
memset(this, 0, sizeof(Test));
|
|
}
|
|
Test(const Test &_o) {
|
|
memcpy(this, &_o, sizeof(Test));
|
|
}
|
|
Test(int16_t _a, int8_t _b)
|
|
: a_(flatbuffers::EndianScalar(_a)),
|
|
b_(flatbuffers::EndianScalar(_b)),
|
|
padding0__(0) {
|
|
(void)padding0__;
|
|
}
|
|
int16_t a() const {
|
|
return flatbuffers::EndianScalar(a_);
|
|
}
|
|
void mutate_a(int16_t _a) {
|
|
flatbuffers::WriteScalar(&a_, _a);
|
|
}
|
|
int8_t b() const {
|
|
return flatbuffers::EndianScalar(b_);
|
|
}
|
|
void mutate_b(int8_t _b) {
|
|
flatbuffers::WriteScalar(&b_, _b);
|
|
}
|
|
};
|
|
STRUCT_END(Test, 4);
|
|
|
|
MANUALLY_ALIGNED_STRUCT(16) Vec3 FLATBUFFERS_FINAL_CLASS {
|
|
private:
|
|
float x_;
|
|
float y_;
|
|
float z_;
|
|
int32_t padding0__;
|
|
double test1_;
|
|
int8_t test2_;
|
|
int8_t padding1__;
|
|
Test test3_;
|
|
int16_t padding2__;
|
|
|
|
public:
|
|
Vec3() {
|
|
memset(this, 0, sizeof(Vec3));
|
|
}
|
|
Vec3(const Vec3 &_o) {
|
|
memcpy(this, &_o, sizeof(Vec3));
|
|
}
|
|
Vec3(float _x, float _y, float _z, double _test1, Color _test2, const Test &_test3)
|
|
: x_(flatbuffers::EndianScalar(_x)),
|
|
y_(flatbuffers::EndianScalar(_y)),
|
|
z_(flatbuffers::EndianScalar(_z)),
|
|
padding0__(0),
|
|
test1_(flatbuffers::EndianScalar(_test1)),
|
|
test2_(flatbuffers::EndianScalar(static_cast<int8_t>(_test2))),
|
|
padding1__(0),
|
|
test3_(_test3),
|
|
padding2__(0) {
|
|
(void)padding0__;
|
|
(void)padding1__;
|
|
(void)padding2__;
|
|
}
|
|
float x() const {
|
|
return flatbuffers::EndianScalar(x_);
|
|
}
|
|
void mutate_x(float _x) {
|
|
flatbuffers::WriteScalar(&x_, _x);
|
|
}
|
|
float y() const {
|
|
return flatbuffers::EndianScalar(y_);
|
|
}
|
|
void mutate_y(float _y) {
|
|
flatbuffers::WriteScalar(&y_, _y);
|
|
}
|
|
float z() const {
|
|
return flatbuffers::EndianScalar(z_);
|
|
}
|
|
void mutate_z(float _z) {
|
|
flatbuffers::WriteScalar(&z_, _z);
|
|
}
|
|
double test1() const {
|
|
return flatbuffers::EndianScalar(test1_);
|
|
}
|
|
void mutate_test1(double _test1) {
|
|
flatbuffers::WriteScalar(&test1_, _test1);
|
|
}
|
|
Color test2() const {
|
|
return static_cast<Color>(flatbuffers::EndianScalar(test2_));
|
|
}
|
|
void mutate_test2(Color _test2) {
|
|
flatbuffers::WriteScalar(&test2_, static_cast<int8_t>(_test2));
|
|
}
|
|
const Test &test3() const {
|
|
return test3_;
|
|
}
|
|
Test &mutable_test3() {
|
|
return test3_;
|
|
}
|
|
};
|
|
STRUCT_END(Vec3, 32);
|
|
|
|
MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS {
|
|
private:
|
|
uint32_t id_;
|
|
uint32_t distance_;
|
|
|
|
public:
|
|
Ability() {
|
|
memset(this, 0, sizeof(Ability));
|
|
}
|
|
Ability(const Ability &_o) {
|
|
memcpy(this, &_o, sizeof(Ability));
|
|
}
|
|
Ability(uint32_t _id, uint32_t _distance)
|
|
: id_(flatbuffers::EndianScalar(_id)),
|
|
distance_(flatbuffers::EndianScalar(_distance)) {
|
|
}
|
|
uint32_t id() const {
|
|
return flatbuffers::EndianScalar(id_);
|
|
}
|
|
void mutate_id(uint32_t _id) {
|
|
flatbuffers::WriteScalar(&id_, _id);
|
|
}
|
|
bool KeyCompareLessThan(const Ability *o) const {
|
|
return id() < o->id();
|
|
}
|
|
int KeyCompareWithValue(uint32_t val) const {
|
|
const auto key = id();
|
|
return static_cast<int>(key > val) - static_cast<int>(key < val);
|
|
}
|
|
uint32_t distance() const {
|
|
return flatbuffers::EndianScalar(distance_);
|
|
}
|
|
void mutate_distance(uint32_t _distance) {
|
|
flatbuffers::WriteScalar(&distance_, _distance);
|
|
}
|
|
};
|
|
STRUCT_END(Ability, 8);
|
|
|
|
} // namespace Example
|
|
|
|
namespace Example2 {
|
|
|
|
struct MonsterT : public flatbuffers::NativeTable {
|
|
typedef Monster TableType;
|
|
MonsterT() {
|
|
}
|
|
};
|
|
|
|
struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef MonsterT NativeTableType;
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
verifier.EndTable();
|
|
}
|
|
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
};
|
|
|
|
struct MonsterBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
MonsterBuilder &operator=(const MonsterBuilder &);
|
|
flatbuffers::Offset<Monster> Finish() {
|
|
const auto end = fbb_.EndTable(start_, 0);
|
|
auto o = flatbuffers::Offset<Monster>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Monster> CreateMonster(
|
|
flatbuffers::FlatBufferBuilder &_fbb) {
|
|
MonsterBuilder builder_(_fbb);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
|
|
} // namespace Example2
|
|
|
|
namespace Example {
|
|
|
|
struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable {
|
|
typedef TestSimpleTableWithEnum TableType;
|
|
Color color;
|
|
TestSimpleTableWithEnumT()
|
|
: color(Color_Green) {
|
|
}
|
|
};
|
|
|
|
struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef TestSimpleTableWithEnumT NativeTableType;
|
|
enum {
|
|
VT_COLOR = 4
|
|
};
|
|
Color color() const {
|
|
return static_cast<Color>(GetField<int8_t>(VT_COLOR, 2));
|
|
}
|
|
bool mutate_color(Color _color) {
|
|
return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int8_t>(verifier, VT_COLOR) &&
|
|
verifier.EndTable();
|
|
}
|
|
TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
static flatbuffers::Offset<TestSimpleTableWithEnum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
};
|
|
|
|
struct TestSimpleTableWithEnumBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_color(Color color) {
|
|
fbb_.AddElement<int8_t>(TestSimpleTableWithEnum::VT_COLOR, static_cast<int8_t>(color), 2);
|
|
}
|
|
TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
TestSimpleTableWithEnumBuilder &operator=(const TestSimpleTableWithEnumBuilder &);
|
|
flatbuffers::Offset<TestSimpleTableWithEnum> Finish() {
|
|
const auto end = fbb_.EndTable(start_, 1);
|
|
auto o = flatbuffers::Offset<TestSimpleTableWithEnum>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
Color color = Color_Green) {
|
|
TestSimpleTableWithEnumBuilder builder_(_fbb);
|
|
builder_.add_color(color);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
|
|
struct StatT : public flatbuffers::NativeTable {
|
|
typedef Stat TableType;
|
|
std::string id;
|
|
int64_t val;
|
|
uint16_t count;
|
|
StatT()
|
|
: val(0),
|
|
count(0) {
|
|
}
|
|
};
|
|
|
|
struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef StatT NativeTableType;
|
|
enum {
|
|
VT_ID = 4,
|
|
VT_VAL = 6,
|
|
VT_COUNT = 8
|
|
};
|
|
const flatbuffers::String *id() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_ID);
|
|
}
|
|
flatbuffers::String *mutable_id() {
|
|
return GetPointer<flatbuffers::String *>(VT_ID);
|
|
}
|
|
int64_t val() const {
|
|
return GetField<int64_t>(VT_VAL, 0);
|
|
}
|
|
bool mutate_val(int64_t _val) {
|
|
return SetField<int64_t>(VT_VAL, _val, 0);
|
|
}
|
|
uint16_t count() const {
|
|
return GetField<uint16_t>(VT_COUNT, 0);
|
|
}
|
|
bool mutate_count(uint16_t _count) {
|
|
return SetField<uint16_t>(VT_COUNT, _count, 0);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ID) &&
|
|
verifier.Verify(id()) &&
|
|
VerifyField<int64_t>(verifier, VT_VAL) &&
|
|
VerifyField<uint16_t>(verifier, VT_COUNT) &&
|
|
verifier.EndTable();
|
|
}
|
|
StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
static flatbuffers::Offset<Stat> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
};
|
|
|
|
struct StatBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_id(flatbuffers::Offset<flatbuffers::String> id) {
|
|
fbb_.AddOffset(Stat::VT_ID, id);
|
|
}
|
|
void add_val(int64_t val) {
|
|
fbb_.AddElement<int64_t>(Stat::VT_VAL, val, 0);
|
|
}
|
|
void add_count(uint16_t count) {
|
|
fbb_.AddElement<uint16_t>(Stat::VT_COUNT, count, 0);
|
|
}
|
|
StatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
StatBuilder &operator=(const StatBuilder &);
|
|
flatbuffers::Offset<Stat> Finish() {
|
|
const auto end = fbb_.EndTable(start_, 3);
|
|
auto o = flatbuffers::Offset<Stat>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Stat> CreateStat(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::String> id = 0,
|
|
int64_t val = 0,
|
|
uint16_t count = 0) {
|
|
StatBuilder builder_(_fbb);
|
|
builder_.add_val(val);
|
|
builder_.add_id(id);
|
|
builder_.add_count(count);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Stat> CreateStatDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *id = nullptr,
|
|
int64_t val = 0,
|
|
uint16_t count = 0) {
|
|
return MyGame::Example::CreateStat(
|
|
_fbb,
|
|
id ? _fbb.CreateString(id) : 0,
|
|
val,
|
|
count);
|
|
}
|
|
|
|
flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
|
|
struct MonsterT : public flatbuffers::NativeTable {
|
|
typedef Monster TableType;
|
|
std::unique_ptr<Vec3> pos;
|
|
int16_t mana;
|
|
int16_t hp;
|
|
std::string name;
|
|
std::vector<uint8_t> inventory;
|
|
Color color;
|
|
AnyUnion test;
|
|
std::vector<Test> test4;
|
|
std::vector<std::string> testarrayofstring;
|
|
std::vector<std::unique_ptr<MonsterT>> testarrayoftables;
|
|
std::unique_ptr<MonsterT> enemy;
|
|
std::vector<uint8_t> testnestedflatbuffer;
|
|
std::unique_ptr<StatT> testempty;
|
|
bool testbool;
|
|
int32_t testhashs32_fnv1;
|
|
uint32_t testhashu32_fnv1;
|
|
int64_t testhashs64_fnv1;
|
|
uint64_t testhashu64_fnv1;
|
|
int32_t testhashs32_fnv1a;
|
|
Stat *testhashu32_fnv1a;
|
|
int64_t testhashs64_fnv1a;
|
|
uint64_t testhashu64_fnv1a;
|
|
std::vector<bool> testarrayofbools;
|
|
float testf;
|
|
float testf2;
|
|
float testf3;
|
|
std::vector<std::string> testarrayofstring2;
|
|
std::vector<Ability> testarrayofsortedstruct;
|
|
MonsterT()
|
|
: mana(150),
|
|
hp(100),
|
|
color(Color_Blue),
|
|
testbool(false),
|
|
testhashs32_fnv1(0),
|
|
testhashu32_fnv1(0),
|
|
testhashs64_fnv1(0),
|
|
testhashu64_fnv1(0),
|
|
testhashs32_fnv1a(0),
|
|
testhashu32_fnv1a(0),
|
|
testhashs64_fnv1a(0),
|
|
testhashu64_fnv1a(0),
|
|
testf(3.14159f),
|
|
testf2(3.0f),
|
|
testf3(0.0f) {
|
|
}
|
|
};
|
|
|
|
/// an example documentation comment: monster object
|
|
struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef MonsterT NativeTableType;
|
|
enum {
|
|
VT_POS = 4,
|
|
VT_MANA = 6,
|
|
VT_HP = 8,
|
|
VT_NAME = 10,
|
|
VT_INVENTORY = 14,
|
|
VT_COLOR = 16,
|
|
VT_TEST_TYPE = 18,
|
|
VT_TEST = 20,
|
|
VT_TEST4 = 22,
|
|
VT_TESTARRAYOFSTRING = 24,
|
|
VT_TESTARRAYOFTABLES = 26,
|
|
VT_ENEMY = 28,
|
|
VT_TESTNESTEDFLATBUFFER = 30,
|
|
VT_TESTEMPTY = 32,
|
|
VT_TESTBOOL = 34,
|
|
VT_TESTHASHS32_FNV1 = 36,
|
|
VT_TESTHASHU32_FNV1 = 38,
|
|
VT_TESTHASHS64_FNV1 = 40,
|
|
VT_TESTHASHU64_FNV1 = 42,
|
|
VT_TESTHASHS32_FNV1A = 44,
|
|
VT_TESTHASHU32_FNV1A = 46,
|
|
VT_TESTHASHS64_FNV1A = 48,
|
|
VT_TESTHASHU64_FNV1A = 50,
|
|
VT_TESTARRAYOFBOOLS = 52,
|
|
VT_TESTF = 54,
|
|
VT_TESTF2 = 56,
|
|
VT_TESTF3 = 58,
|
|
VT_TESTARRAYOFSTRING2 = 60,
|
|
VT_TESTARRAYOFSORTEDSTRUCT = 62
|
|
};
|
|
const Vec3 *pos() const {
|
|
return GetStruct<const Vec3 *>(VT_POS);
|
|
}
|
|
Vec3 *mutable_pos() {
|
|
return GetStruct<Vec3 *>(VT_POS);
|
|
}
|
|
int16_t mana() const {
|
|
return GetField<int16_t>(VT_MANA, 150);
|
|
}
|
|
bool mutate_mana(int16_t _mana) {
|
|
return SetField<int16_t>(VT_MANA, _mana, 150);
|
|
}
|
|
int16_t hp() const {
|
|
return GetField<int16_t>(VT_HP, 100);
|
|
}
|
|
bool mutate_hp(int16_t _hp) {
|
|
return SetField<int16_t>(VT_HP, _hp, 100);
|
|
}
|
|
const flatbuffers::String *name() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_NAME);
|
|
}
|
|
flatbuffers::String *mutable_name() {
|
|
return GetPointer<flatbuffers::String *>(VT_NAME);
|
|
}
|
|
bool KeyCompareLessThan(const Monster *o) const {
|
|
return *name() < *o->name();
|
|
}
|
|
int KeyCompareWithValue(const char *val) const {
|
|
return strcmp(name()->c_str(), val);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *inventory() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_inventory() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
|
|
}
|
|
Color color() const {
|
|
return static_cast<Color>(GetField<int8_t>(VT_COLOR, 8));
|
|
}
|
|
bool mutate_color(Color _color) {
|
|
return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 8);
|
|
}
|
|
Any test_type() const {
|
|
return static_cast<Any>(GetField<uint8_t>(VT_TEST_TYPE, 0));
|
|
}
|
|
bool mutate_test_type(Any _test_type) {
|
|
return SetField<uint8_t>(VT_TEST_TYPE, static_cast<uint8_t>(_test_type), 0);
|
|
}
|
|
const void *test() const {
|
|
return GetPointer<const void *>(VT_TEST);
|
|
}
|
|
template<typename T> const T *test_as() const;
|
|
const Monster *test_as_Monster() const {
|
|
return test_type() == Any_Monster ? static_cast<const Monster *>(test()) : nullptr;
|
|
}
|
|
const TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const {
|
|
return test_type() == Any_TestSimpleTableWithEnum ? static_cast<const TestSimpleTableWithEnum *>(test()) : nullptr;
|
|
}
|
|
const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
|
|
return test_type() == Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
|
|
}
|
|
void *mutable_test() {
|
|
return GetPointer<void *>(VT_TEST);
|
|
}
|
|
const flatbuffers::Vector<const Test *> *test4() const {
|
|
return GetPointer<const flatbuffers::Vector<const Test *> *>(VT_TEST4);
|
|
}
|
|
flatbuffers::Vector<const Test *> *mutable_test4() {
|
|
return GetPointer<flatbuffers::Vector<const Test *> *>(VT_TEST4);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING);
|
|
}
|
|
/// an example documentation comment: this will end up in the generated code
|
|
/// multiline too
|
|
const flatbuffers::Vector<flatbuffers::Offset<Monster>> *testarrayoftables() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<Monster>> *mutable_testarrayoftables() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(VT_TESTARRAYOFTABLES);
|
|
}
|
|
const Monster *enemy() const {
|
|
return GetPointer<const Monster *>(VT_ENEMY);
|
|
}
|
|
Monster *mutable_enemy() {
|
|
return GetPointer<Monster *>(VT_ENEMY);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_testnestedflatbuffer() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTNESTEDFLATBUFFER);
|
|
}
|
|
const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const {
|
|
const uint8_t* data = testnestedflatbuffer()->Data();
|
|
return flatbuffers::GetRoot<MyGame::Example::Monster>(data);
|
|
}
|
|
const Stat *testempty() const {
|
|
return GetPointer<const Stat *>(VT_TESTEMPTY);
|
|
}
|
|
Stat *mutable_testempty() {
|
|
return GetPointer<Stat *>(VT_TESTEMPTY);
|
|
}
|
|
bool testbool() const {
|
|
return GetField<uint8_t>(VT_TESTBOOL, 0) != 0;
|
|
}
|
|
bool mutate_testbool(bool _testbool) {
|
|
return SetField<uint8_t>(VT_TESTBOOL, static_cast<uint8_t>(_testbool), 0);
|
|
}
|
|
int32_t testhashs32_fnv1() const {
|
|
return GetField<int32_t>(VT_TESTHASHS32_FNV1, 0);
|
|
}
|
|
bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1) {
|
|
return SetField<int32_t>(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0);
|
|
}
|
|
uint32_t testhashu32_fnv1() const {
|
|
return GetField<uint32_t>(VT_TESTHASHU32_FNV1, 0);
|
|
}
|
|
bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1) {
|
|
return SetField<uint32_t>(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0);
|
|
}
|
|
int64_t testhashs64_fnv1() const {
|
|
return GetField<int64_t>(VT_TESTHASHS64_FNV1, 0);
|
|
}
|
|
bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1) {
|
|
return SetField<int64_t>(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0);
|
|
}
|
|
uint64_t testhashu64_fnv1() const {
|
|
return GetField<uint64_t>(VT_TESTHASHU64_FNV1, 0);
|
|
}
|
|
bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1) {
|
|
return SetField<uint64_t>(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0);
|
|
}
|
|
int32_t testhashs32_fnv1a() const {
|
|
return GetField<int32_t>(VT_TESTHASHS32_FNV1A, 0);
|
|
}
|
|
bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a) {
|
|
return SetField<int32_t>(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0);
|
|
}
|
|
uint32_t testhashu32_fnv1a() const {
|
|
return GetField<uint32_t>(VT_TESTHASHU32_FNV1A, 0);
|
|
}
|
|
bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a) {
|
|
return SetField<uint32_t>(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0);
|
|
}
|
|
int64_t testhashs64_fnv1a() const {
|
|
return GetField<int64_t>(VT_TESTHASHS64_FNV1A, 0);
|
|
}
|
|
bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a) {
|
|
return SetField<int64_t>(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0);
|
|
}
|
|
uint64_t testhashu64_fnv1a() const {
|
|
return GetField<uint64_t>(VT_TESTHASHU64_FNV1A, 0);
|
|
}
|
|
bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a) {
|
|
return SetField<uint64_t>(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *testarrayofbools() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_testarrayofbools() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTARRAYOFBOOLS);
|
|
}
|
|
float testf() const {
|
|
return GetField<float>(VT_TESTF, 3.14159f);
|
|
}
|
|
bool mutate_testf(float _testf) {
|
|
return SetField<float>(VT_TESTF, _testf, 3.14159f);
|
|
}
|
|
float testf2() const {
|
|
return GetField<float>(VT_TESTF2, 3.0f);
|
|
}
|
|
bool mutate_testf2(float _testf2) {
|
|
return SetField<float>(VT_TESTF2, _testf2, 3.0f);
|
|
}
|
|
float testf3() const {
|
|
return GetField<float>(VT_TESTF3, 0.0f);
|
|
}
|
|
bool mutate_testf3(float _testf3) {
|
|
return SetField<float>(VT_TESTF3, _testf3, 0.0f);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *mutable_testarrayofstring2() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TESTARRAYOFSTRING2);
|
|
}
|
|
const flatbuffers::Vector<const Ability *> *testarrayofsortedstruct() const {
|
|
return GetPointer<const flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
|
|
}
|
|
flatbuffers::Vector<const Ability *> *mutable_testarrayofsortedstruct() {
|
|
return GetPointer<flatbuffers::Vector<const Ability *> *>(VT_TESTARRAYOFSORTEDSTRUCT);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<Vec3>(verifier, VT_POS) &&
|
|
VerifyField<int16_t>(verifier, VT_MANA) &&
|
|
VerifyField<int16_t>(verifier, VT_HP) &&
|
|
VerifyOffsetRequired(verifier, VT_NAME) &&
|
|
verifier.Verify(name()) &&
|
|
VerifyOffset(verifier, VT_INVENTORY) &&
|
|
verifier.Verify(inventory()) &&
|
|
VerifyField<int8_t>(verifier, VT_COLOR) &&
|
|
VerifyField<uint8_t>(verifier, VT_TEST_TYPE) &&
|
|
VerifyOffset(verifier, VT_TEST) &&
|
|
VerifyAny(verifier, test(), test_type()) &&
|
|
VerifyOffset(verifier, VT_TEST4) &&
|
|
verifier.Verify(test4()) &&
|
|
VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
|
|
verifier.Verify(testarrayofstring()) &&
|
|
verifier.VerifyVectorOfStrings(testarrayofstring()) &&
|
|
VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
|
|
verifier.Verify(testarrayoftables()) &&
|
|
verifier.VerifyVectorOfTables(testarrayoftables()) &&
|
|
VerifyOffset(verifier, VT_ENEMY) &&
|
|
verifier.VerifyTable(enemy()) &&
|
|
VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
|
|
verifier.Verify(testnestedflatbuffer()) &&
|
|
VerifyOffset(verifier, VT_TESTEMPTY) &&
|
|
verifier.VerifyTable(testempty()) &&
|
|
VerifyField<uint8_t>(verifier, VT_TESTBOOL) &&
|
|
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1) &&
|
|
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1) &&
|
|
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1) &&
|
|
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1) &&
|
|
VerifyField<int32_t>(verifier, VT_TESTHASHS32_FNV1A) &&
|
|
VerifyField<uint32_t>(verifier, VT_TESTHASHU32_FNV1A) &&
|
|
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) &&
|
|
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) &&
|
|
VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
|
|
verifier.Verify(testarrayofbools()) &&
|
|
VerifyField<float>(verifier, VT_TESTF) &&
|
|
VerifyField<float>(verifier, VT_TESTF2) &&
|
|
VerifyField<float>(verifier, VT_TESTF3) &&
|
|
VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
|
|
verifier.Verify(testarrayofstring2()) &&
|
|
verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
|
|
VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
|
|
verifier.Verify(testarrayofsortedstruct()) &&
|
|
verifier.EndTable();
|
|
}
|
|
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
|
static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
};
|
|
|
|
template<> inline const Monster *Monster::test_as<Monster>() const {
|
|
return test_as_Monster();
|
|
}
|
|
|
|
template<> inline const TestSimpleTableWithEnum *Monster::test_as<TestSimpleTableWithEnum>() const {
|
|
return test_as_TestSimpleTableWithEnum();
|
|
}
|
|
|
|
template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
|
|
return test_as_MyGame_Example2_Monster();
|
|
}
|
|
|
|
struct MonsterBuilder {
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_pos(const Vec3 *pos) {
|
|
fbb_.AddStruct(Monster::VT_POS, pos);
|
|
}
|
|
void add_mana(int16_t mana) {
|
|
fbb_.AddElement<int16_t>(Monster::VT_MANA, mana, 150);
|
|
}
|
|
void add_hp(int16_t hp) {
|
|
fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
|
|
}
|
|
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
|
|
fbb_.AddOffset(Monster::VT_NAME, name);
|
|
}
|
|
void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) {
|
|
fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
|
|
}
|
|
void add_color(Color color) {
|
|
fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 8);
|
|
}
|
|
void add_test_type(Any test_type) {
|
|
fbb_.AddElement<uint8_t>(Monster::VT_TEST_TYPE, static_cast<uint8_t>(test_type), 0);
|
|
}
|
|
void add_test(flatbuffers::Offset<void> test) {
|
|
fbb_.AddOffset(Monster::VT_TEST, test);
|
|
}
|
|
void add_test4(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4) {
|
|
fbb_.AddOffset(Monster::VT_TEST4, test4);
|
|
}
|
|
void add_testarrayofstring(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring) {
|
|
fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring);
|
|
}
|
|
void add_testarrayoftables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables) {
|
|
fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables);
|
|
}
|
|
void add_enemy(flatbuffers::Offset<Monster> enemy) {
|
|
fbb_.AddOffset(Monster::VT_ENEMY, enemy);
|
|
}
|
|
void add_testnestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer) {
|
|
fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer);
|
|
}
|
|
void add_testempty(flatbuffers::Offset<Stat> testempty) {
|
|
fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty);
|
|
}
|
|
void add_testbool(bool testbool) {
|
|
fbb_.AddElement<uint8_t>(Monster::VT_TESTBOOL, static_cast<uint8_t>(testbool), 0);
|
|
}
|
|
void add_testhashs32_fnv1(int32_t testhashs32_fnv1) {
|
|
fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0);
|
|
}
|
|
void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) {
|
|
fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0);
|
|
}
|
|
void add_testhashs64_fnv1(int64_t testhashs64_fnv1) {
|
|
fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0);
|
|
}
|
|
void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) {
|
|
fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0);
|
|
}
|
|
void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) {
|
|
fbb_.AddElement<int32_t>(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0);
|
|
}
|
|
void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) {
|
|
fbb_.AddElement<uint32_t>(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0);
|
|
}
|
|
void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) {
|
|
fbb_.AddElement<int64_t>(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0);
|
|
}
|
|
void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) {
|
|
fbb_.AddElement<uint64_t>(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0);
|
|
}
|
|
void add_testarrayofbools(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools) {
|
|
fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools);
|
|
}
|
|
void add_testf(float testf) {
|
|
fbb_.AddElement<float>(Monster::VT_TESTF, testf, 3.14159f);
|
|
}
|
|
void add_testf2(float testf2) {
|
|
fbb_.AddElement<float>(Monster::VT_TESTF2, testf2, 3.0f);
|
|
}
|
|
void add_testf3(float testf3) {
|
|
fbb_.AddElement<float>(Monster::VT_TESTF3, testf3, 0.0f);
|
|
}
|
|
void add_testarrayofstring2(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2) {
|
|
fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2);
|
|
}
|
|
void add_testarrayofsortedstruct(flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct) {
|
|
fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct);
|
|
}
|
|
MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
MonsterBuilder &operator=(const MonsterBuilder &);
|
|
flatbuffers::Offset<Monster> Finish() {
|
|
const auto end = fbb_.EndTable(start_, 30);
|
|
auto o = flatbuffers::Offset<Monster>(end);
|
|
fbb_.Required(o, Monster::VT_NAME);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Monster> CreateMonster(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const Vec3 *pos = 0,
|
|
int16_t mana = 150,
|
|
int16_t hp = 100,
|
|
flatbuffers::Offset<flatbuffers::String> name = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
|
|
Color color = Color_Blue,
|
|
Any test_type = Any_NONE,
|
|
flatbuffers::Offset<void> test = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4 = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables = 0,
|
|
flatbuffers::Offset<Monster> enemy = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
|
|
flatbuffers::Offset<Stat> testempty = 0,
|
|
bool testbool = false,
|
|
int32_t testhashs32_fnv1 = 0,
|
|
uint32_t testhashu32_fnv1 = 0,
|
|
int64_t testhashs64_fnv1 = 0,
|
|
uint64_t testhashu64_fnv1 = 0,
|
|
int32_t testhashs32_fnv1a = 0,
|
|
uint32_t testhashu32_fnv1a = 0,
|
|
int64_t testhashs64_fnv1a = 0,
|
|
uint64_t testhashu64_fnv1a = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testarrayofbools = 0,
|
|
float testf = 3.14159f,
|
|
float testf2 = 3.0f,
|
|
float testf3 = 0.0f,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring2 = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<const Ability *>> testarrayofsortedstruct = 0) {
|
|
MonsterBuilder builder_(_fbb);
|
|
builder_.add_testhashu64_fnv1a(testhashu64_fnv1a);
|
|
builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
|
|
builder_.add_testhashu64_fnv1(testhashu64_fnv1);
|
|
builder_.add_testhashs64_fnv1(testhashs64_fnv1);
|
|
builder_.add_testarrayofsortedstruct(testarrayofsortedstruct);
|
|
builder_.add_testarrayofstring2(testarrayofstring2);
|
|
builder_.add_testf3(testf3);
|
|
builder_.add_testf2(testf2);
|
|
builder_.add_testf(testf);
|
|
builder_.add_testarrayofbools(testarrayofbools);
|
|
builder_.add_testhashu32_fnv1a(testhashu32_fnv1a);
|
|
builder_.add_testhashs32_fnv1a(testhashs32_fnv1a);
|
|
builder_.add_testhashu32_fnv1(testhashu32_fnv1);
|
|
builder_.add_testhashs32_fnv1(testhashs32_fnv1);
|
|
builder_.add_testempty(testempty);
|
|
builder_.add_testnestedflatbuffer(testnestedflatbuffer);
|
|
builder_.add_enemy(enemy);
|
|
builder_.add_testarrayoftables(testarrayoftables);
|
|
builder_.add_testarrayofstring(testarrayofstring);
|
|
builder_.add_test4(test4);
|
|
builder_.add_test(test);
|
|
builder_.add_inventory(inventory);
|
|
builder_.add_name(name);
|
|
builder_.add_pos(pos);
|
|
builder_.add_hp(hp);
|
|
builder_.add_mana(mana);
|
|
builder_.add_testbool(testbool);
|
|
builder_.add_test_type(test_type);
|
|
builder_.add_color(color);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Monster> CreateMonsterDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const Vec3 *pos = 0,
|
|
int16_t mana = 150,
|
|
int16_t hp = 100,
|
|
const char *name = nullptr,
|
|
const std::vector<uint8_t> *inventory = nullptr,
|
|
Color color = Color_Blue,
|
|
Any test_type = Any_NONE,
|
|
flatbuffers::Offset<void> test = 0,
|
|
const std::vector<const Test *> *test4 = nullptr,
|
|
const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring = nullptr,
|
|
const std::vector<flatbuffers::Offset<Monster>> *testarrayoftables = nullptr,
|
|
flatbuffers::Offset<Monster> enemy = 0,
|
|
const std::vector<uint8_t> *testnestedflatbuffer = nullptr,
|
|
flatbuffers::Offset<Stat> testempty = 0,
|
|
bool testbool = false,
|
|
int32_t testhashs32_fnv1 = 0,
|
|
uint32_t testhashu32_fnv1 = 0,
|
|
int64_t testhashs64_fnv1 = 0,
|
|
uint64_t testhashu64_fnv1 = 0,
|
|
int32_t testhashs32_fnv1a = 0,
|
|
uint32_t testhashu32_fnv1a = 0,
|
|
int64_t testhashs64_fnv1a = 0,
|
|
uint64_t testhashu64_fnv1a = 0,
|
|
const std::vector<uint8_t> *testarrayofbools = nullptr,
|
|
float testf = 3.14159f,
|
|
float testf2 = 3.0f,
|
|
float testf3 = 0.0f,
|
|
const std::vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring2 = nullptr,
|
|
const std::vector<const Ability *> *testarrayofsortedstruct = nullptr) {
|
|
return MyGame::Example::CreateMonster(
|
|
_fbb,
|
|
pos,
|
|
mana,
|
|
hp,
|
|
name ? _fbb.CreateString(name) : 0,
|
|
inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0,
|
|
color,
|
|
test_type,
|
|
test,
|
|
test4 ? _fbb.CreateVector<const Test *>(*test4) : 0,
|
|
testarrayofstring ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring) : 0,
|
|
testarrayoftables ? _fbb.CreateVector<flatbuffers::Offset<Monster>>(*testarrayoftables) : 0,
|
|
enemy,
|
|
testnestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testnestedflatbuffer) : 0,
|
|
testempty,
|
|
testbool,
|
|
testhashs32_fnv1,
|
|
testhashu32_fnv1,
|
|
testhashs64_fnv1,
|
|
testhashu64_fnv1,
|
|
testhashs32_fnv1a,
|
|
testhashu32_fnv1a,
|
|
testhashs64_fnv1a,
|
|
testhashu64_fnv1a,
|
|
testarrayofbools ? _fbb.CreateVector<uint8_t>(*testarrayofbools) : 0,
|
|
testf,
|
|
testf2,
|
|
testf3,
|
|
testarrayofstring2 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*testarrayofstring2) : 0,
|
|
testarrayofsortedstruct ? _fbb.CreateVector<const Ability *>(*testarrayofsortedstruct) : 0);
|
|
}
|
|
|
|
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
|
|
|
} // namespace Example
|
|
|
|
namespace Example2 {
|
|
|
|
inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
|
auto _o = new MonsterT();
|
|
UnPackTo(_o, _resolver);
|
|
return _o;
|
|
}
|
|
|
|
inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
|
(void)_o;
|
|
(void)_resolver;
|
|
}
|
|
|
|
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
return CreateMonster(_fbb, _o, _rehasher);
|
|
}
|
|
|
|
inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
(void)_rehasher;
|
|
(void)_o;
|
|
return MyGame::Example2::CreateMonster(
|
|
_fbb);
|
|
}
|
|
|
|
} // namespace Example2
|
|
|
|
namespace Example {
|
|
|
|
inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
|
auto _o = new TestSimpleTableWithEnumT();
|
|
UnPackTo(_o, _resolver);
|
|
return _o;
|
|
}
|
|
|
|
inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
|
(void)_o;
|
|
(void)_resolver;
|
|
{ auto _e = color(); _o->color = _e; };
|
|
}
|
|
|
|
inline flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher);
|
|
}
|
|
|
|
inline flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
(void)_rehasher;
|
|
(void)_o;
|
|
auto _color = _o->color;
|
|
return MyGame::Example::CreateTestSimpleTableWithEnum(
|
|
_fbb,
|
|
_color);
|
|
}
|
|
|
|
inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
|
auto _o = new StatT();
|
|
UnPackTo(_o, _resolver);
|
|
return _o;
|
|
}
|
|
|
|
inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
|
(void)_o;
|
|
(void)_resolver;
|
|
{ auto _e = id(); if (_e) _o->id = _e->str(); };
|
|
{ auto _e = val(); _o->val = _e; };
|
|
{ auto _e = count(); _o->count = _e; };
|
|
}
|
|
|
|
inline flatbuffers::Offset<Stat> Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
return CreateStat(_fbb, _o, _rehasher);
|
|
}
|
|
|
|
inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
(void)_rehasher;
|
|
(void)_o;
|
|
auto _id = _o->id.size() ? _fbb.CreateString(_o->id) : 0;
|
|
auto _val = _o->val;
|
|
auto _count = _o->count;
|
|
return MyGame::Example::CreateStat(
|
|
_fbb,
|
|
_id,
|
|
_val,
|
|
_count);
|
|
}
|
|
|
|
inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
|
auto _o = new MonsterT();
|
|
UnPackTo(_o, _resolver);
|
|
return _o;
|
|
}
|
|
|
|
inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
|
(void)_o;
|
|
(void)_resolver;
|
|
{ auto _e = pos(); if (_e) _o->pos = std::unique_ptr<Vec3>(new Vec3(*_e)); };
|
|
{ auto _e = mana(); _o->mana = _e; };
|
|
{ auto _e = hp(); _o->hp = _e; };
|
|
{ auto _e = name(); if (_e) _o->name = _e->str(); };
|
|
{ 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); } } };
|
|
{ auto _e = color(); _o->color = _e; };
|
|
{ auto _e = test_type(); _o->test.type = _e; };
|
|
{ auto _e = test(); if (_e) _o->test.value = AnyUnion::UnPack(_e, test_type(), _resolver); };
|
|
{ auto _e = test4(); if (_e) { _o->test4.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4[_i] = *_e->Get(_i); } } };
|
|
{ auto _e = testarrayofstring(); if (_e) { _o->testarrayofstring.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring[_i] = _e->Get(_i)->str(); } } };
|
|
{ auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = std::unique_ptr<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } };
|
|
{ auto _e = enemy(); if (_e) _o->enemy = std::unique_ptr<MonsterT>(_e->UnPack(_resolver)); };
|
|
{ auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer[_i] = _e->Get(_i); } } };
|
|
{ auto _e = testempty(); if (_e) _o->testempty = std::unique_ptr<StatT>(_e->UnPack(_resolver)); };
|
|
{ auto _e = testbool(); _o->testbool = _e; };
|
|
{ auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; };
|
|
{ auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; };
|
|
{ auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; };
|
|
{ auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; };
|
|
{ auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; };
|
|
{ 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; };
|
|
{ auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; };
|
|
{ auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; };
|
|
{ auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } };
|
|
{ auto _e = testf(); _o->testf = _e; };
|
|
{ auto _e = testf2(); _o->testf2 = _e; };
|
|
{ auto _e = testf3(); _o->testf3 = _e; };
|
|
{ auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } };
|
|
{ auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } };
|
|
}
|
|
|
|
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
return CreateMonster(_fbb, _o, _rehasher);
|
|
}
|
|
|
|
inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
|
(void)_rehasher;
|
|
(void)_o;
|
|
auto _pos = _o->pos ? _o->pos.get() : 0;
|
|
auto _mana = _o->mana;
|
|
auto _hp = _o->hp;
|
|
auto _name = _fbb.CreateString(_o->name);
|
|
auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
|
|
auto _color = _o->color;
|
|
auto _test_type = _o->test.type;
|
|
auto _test = _o->test.Pack(_fbb);
|
|
auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
|
|
auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
|
|
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;
|
|
auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
|
|
auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
|
|
auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
|
|
auto _testbool = _o->testbool;
|
|
auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
|
|
auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
|
|
auto _testhashs64_fnv1 = _o->testhashs64_fnv1;
|
|
auto _testhashu64_fnv1 = _o->testhashu64_fnv1;
|
|
auto _testhashs32_fnv1a = _o->testhashs32_fnv1a;
|
|
auto _testhashu32_fnv1a = _rehasher ? static_cast<uint32_t>((*_rehasher)(_o->testhashu32_fnv1a)) : 0;
|
|
auto _testhashs64_fnv1a = _o->testhashs64_fnv1a;
|
|
auto _testhashu64_fnv1a = _o->testhashu64_fnv1a;
|
|
auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0;
|
|
auto _testf = _o->testf;
|
|
auto _testf2 = _o->testf2;
|
|
auto _testf3 = _o->testf3;
|
|
auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0;
|
|
auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0;
|
|
return MyGame::Example::CreateMonster(
|
|
_fbb,
|
|
_pos,
|
|
_mana,
|
|
_hp,
|
|
_name,
|
|
_inventory,
|
|
_color,
|
|
_test_type,
|
|
_test,
|
|
_test4,
|
|
_testarrayofstring,
|
|
_testarrayoftables,
|
|
_enemy,
|
|
_testnestedflatbuffer,
|
|
_testempty,
|
|
_testbool,
|
|
_testhashs32_fnv1,
|
|
_testhashu32_fnv1,
|
|
_testhashs64_fnv1,
|
|
_testhashu64_fnv1,
|
|
_testhashs32_fnv1a,
|
|
_testhashu32_fnv1a,
|
|
_testhashs64_fnv1a,
|
|
_testhashu64_fnv1a,
|
|
_testarrayofbools,
|
|
_testf,
|
|
_testf2,
|
|
_testf3,
|
|
_testarrayofstring2,
|
|
_testarrayofsortedstruct);
|
|
}
|
|
|
|
inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) {
|
|
switch (type) {
|
|
case Any_NONE: {
|
|
return true;
|
|
}
|
|
case Any_Monster: {
|
|
auto ptr = reinterpret_cast<const Monster *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Any_TestSimpleTableWithEnum: {
|
|
auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Any_MyGame_Example2_Monster: {
|
|
auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
|
|
if (values->size() != types->size()) return false;
|
|
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
|
|
if (!VerifyAny(
|
|
verifier, values->Get(i), types->GetEnum<Any>(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) {
|
|
switch (type) {
|
|
case Any_Monster: {
|
|
auto ptr = reinterpret_cast<const Monster *>(obj);
|
|
return ptr->UnPack(resolver);
|
|
}
|
|
case Any_TestSimpleTableWithEnum: {
|
|
auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
|
|
return ptr->UnPack(resolver);
|
|
}
|
|
case Any_MyGame_Example2_Monster: {
|
|
auto ptr = reinterpret_cast<const MyGame::Example2::Monster *>(obj);
|
|
return ptr->UnPack(resolver);
|
|
}
|
|
default: return nullptr;
|
|
}
|
|
}
|
|
|
|
inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
|
|
switch (type) {
|
|
case Any_Monster: {
|
|
auto ptr = reinterpret_cast<const MonsterT *>(value);
|
|
return CreateMonster(_fbb, ptr, _rehasher).Union();
|
|
}
|
|
case Any_TestSimpleTableWithEnum: {
|
|
auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
|
|
return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
|
|
}
|
|
case Any_MyGame_Example2_Monster: {
|
|
auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
|
|
return CreateMonster(_fbb, ptr, _rehasher).Union();
|
|
}
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
inline AnyUnion::AnyUnion(const AnyUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
|
|
switch (type) {
|
|
case Any_Monster: {
|
|
assert(false); // MonsterT not copyable.
|
|
break;
|
|
}
|
|
case Any_TestSimpleTableWithEnum: {
|
|
value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value));
|
|
break;
|
|
}
|
|
case Any_MyGame_Example2_Monster: {
|
|
value = new MyGame::Example2::MonsterT(*reinterpret_cast<MyGame::Example2::MonsterT *>(u.value));
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
inline void AnyUnion::Reset() {
|
|
switch (type) {
|
|
case Any_Monster: {
|
|
auto ptr = reinterpret_cast<MonsterT *>(value);
|
|
delete ptr;
|
|
break;
|
|
}
|
|
case Any_TestSimpleTableWithEnum: {
|
|
auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
|
|
delete ptr;
|
|
break;
|
|
}
|
|
case Any_MyGame_Example2_Monster: {
|
|
auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
|
|
delete ptr;
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
value = nullptr;
|
|
type = Any_NONE;
|
|
}
|
|
|
|
inline const MyGame::Example::Monster *GetMonster(const void *buf) {
|
|
return flatbuffers::GetRoot<MyGame::Example::Monster>(buf);
|
|
}
|
|
|
|
inline Monster *GetMutableMonster(void *buf) {
|
|
return flatbuffers::GetMutableRoot<Monster>(buf);
|
|
}
|
|
|
|
inline const char *MonsterIdentifier() {
|
|
return "MONS";
|
|
}
|
|
|
|
inline bool MonsterBufferHasIdentifier(const void *buf) {
|
|
return flatbuffers::BufferHasIdentifier(
|
|
buf, MonsterIdentifier());
|
|
}
|
|
|
|
inline bool VerifyMonsterBuffer(
|
|
flatbuffers::Verifier &verifier) {
|
|
return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
|
|
}
|
|
|
|
inline const char *MonsterExtension() {
|
|
return "mon";
|
|
}
|
|
|
|
inline void FinishMonsterBuffer(
|
|
flatbuffers::FlatBufferBuilder &fbb,
|
|
flatbuffers::Offset<MyGame::Example::Monster> root) {
|
|
fbb.Finish(root, MonsterIdentifier());
|
|
}
|
|
|
|
inline std::unique_ptr<MonsterT> UnPackMonster(
|
|
const void *buf,
|
|
const flatbuffers::resolver_function_t *res = nullptr) {
|
|
return std::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res));
|
|
}
|
|
|
|
} // namespace Example
|
|
} // namespace MyGame
|
|
|
|
#endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
|