BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-23 22:01:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make MonsterExtra table a root table (#5315)

Browse Source 
- MonsterExtra table a root table
- add mosterdata_extra.json
This commit is contained in:
Vladimir Glavnyy
2019-05-03 05:12:58 +07:00
committed by Wouter van Oortmerssen
parent b8ef8c1521
commit af74f87ccd
9 changed files with 294 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
tests/monster_extra_generated.h
View File

@@ -24,6 +24,8 @@ struct MonsterExtraT : public flatbuffers::NativeTable {
double testd_nan;
double testd_pinf;
double testd_ninf;
std::vector<float> testf_vec;
std::vector<double> testd_vec;
MonsterExtraT()
: testf_nan(std::numeric_limits<float>::quiet_NaN()),
testf_pinf(std::numeric_limits<float>::infinity()),
@@ -41,7 +43,9 @@ inline bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs) {
(lhs.testf_ninf == rhs.testf_ninf) &&
(lhs.testd_nan == rhs.testd_nan) &&
(lhs.testd_pinf == rhs.testd_pinf) &&
(lhs.testd_ninf == rhs.testd_ninf);
(lhs.testd_ninf == rhs.testd_ninf) &&
(lhs.testf_vec == rhs.testf_vec) &&
(lhs.testd_vec == rhs.testd_vec);
}
inline bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs) {
@@ -60,7 +64,9 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_TESTF_NINF = 8,
VT_TESTD_NAN = 10,
VT_TESTD_PINF = 12,
VT_TESTD_NINF = 14
VT_TESTD_NINF = 14,
VT_TESTF_VEC = 16,
VT_TESTD_VEC = 18
};
float testf_nan() const {
return GetField<float>(VT_TESTF_NAN, std::numeric_limits<float>::quiet_NaN());
@@ -98,6 +104,18 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_testd_ninf(double _testd_ninf) {
return SetField<double>(VT_TESTD_NINF, _testd_ninf, -std::numeric_limits<double>::infinity());
}
const flatbuffers::Vector<float> *testf_vec() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_TESTF_VEC);
}
flatbuffers::Vector<float> *mutable_testf_vec() {
return GetPointer<flatbuffers::Vector<float> *>(VT_TESTF_VEC);
}
const flatbuffers::Vector<double> *testd_vec() const {
return GetPointer<const flatbuffers::Vector<double> *>(VT_TESTD_VEC);
}
flatbuffers::Vector<double> *mutable_testd_vec() {
return GetPointer<flatbuffers::Vector<double> *>(VT_TESTD_VEC);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_TESTF_NAN) &&
@@ -106,6 +124,10 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<double>(verifier, VT_TESTD_NAN) &&
VerifyField<double>(verifier, VT_TESTD_PINF) &&
VerifyField<double>(verifier, VT_TESTD_NINF) &&
VerifyOffset(verifier, VT_TESTF_VEC) &&
verifier.VerifyVector(testf_vec()) &&
VerifyOffset(verifier, VT_TESTD_VEC) &&
verifier.VerifyVector(testd_vec()) &&
verifier.EndTable();
}
MonsterExtraT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -134,6 +156,12 @@ struct MonsterExtraBuilder {
void add_testd_ninf(double testd_ninf) {
fbb_.AddElement<double>(MonsterExtra::VT_TESTD_NINF, testd_ninf, -std::numeric_limits<double>::infinity());
}
void add_testf_vec(flatbuffers::Offset<flatbuffers::Vector<float>> testf_vec) {
fbb_.AddOffset(MonsterExtra::VT_TESTF_VEC, testf_vec);
}
void add_testd_vec(flatbuffers::Offset<flatbuffers::Vector<double>> testd_vec) {
fbb_.AddOffset(MonsterExtra::VT_TESTD_VEC, testd_vec);
}
explicit MonsterExtraBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -153,17 +181,45 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
float testf_ninf = -std::numeric_limits<float>::infinity(),
double testd_nan = std::numeric_limits<double>::quiet_NaN(),
double testd_pinf = std::numeric_limits<double>::infinity(),
double testd_ninf = -std::numeric_limits<double>::infinity()) {
double testd_ninf = -std::numeric_limits<double>::infinity(),
flatbuffers::Offset<flatbuffers::Vector<float>> testf_vec = 0,
flatbuffers::Offset<flatbuffers::Vector<double>> testd_vec = 0) {
MonsterExtraBuilder builder_(_fbb);
builder_.add_testd_ninf(testd_ninf);
builder_.add_testd_pinf(testd_pinf);
builder_.add_testd_nan(testd_nan);
builder_.add_testd_vec(testd_vec);
builder_.add_testf_vec(testf_vec);
builder_.add_testf_ninf(testf_ninf);
builder_.add_testf_pinf(testf_pinf);
builder_.add_testf_nan(testf_nan);
return builder_.Finish();
}
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect(
flatbuffers::FlatBufferBuilder &_fbb,
float testf_nan = std::numeric_limits<float>::quiet_NaN(),
float testf_pinf = std::numeric_limits<float>::infinity(),
float testf_ninf = -std::numeric_limits<float>::infinity(),
double testd_nan = std::numeric_limits<double>::quiet_NaN(),
double testd_pinf = std::numeric_limits<double>::infinity(),
double testd_ninf = -std::numeric_limits<double>::infinity(),
const std::vector<float> *testf_vec = nullptr,
const std::vector<double> *testd_vec = nullptr) {
auto testf_vec__ = testf_vec ? _fbb.CreateVector<float>(*testf_vec) : 0;
auto testd_vec__ = testd_vec ? _fbb.CreateVector<double>(*testd_vec) : 0;
return MyGame::CreateMonsterExtra(
_fbb,
testf_nan,
testf_pinf,
testf_ninf,
testd_nan,
testd_pinf,
testd_ninf,
testf_vec__,
testd_vec__);
}
flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline MonsterExtraT *MonsterExtra::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -181,6 +237,8 @@ inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const flatbuffers::resolve
{ auto _e = testd_nan(); _o->testd_nan = _e; };
{ auto _e = testd_pinf(); _o->testd_pinf = _e; };
{ auto _e = testd_ninf(); _o->testd_ninf = _e; };
{ auto _e = testf_vec(); if (_e) { _o->testf_vec.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testf_vec[_i] = _e->Get(_i); } } };
{ auto _e = testd_vec(); if (_e) { _o->testd_vec.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testd_vec[_i] = _e->Get(_i); } } };
}
inline flatbuffers::Offset<MonsterExtra> MonsterExtra::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -197,6 +255,8 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBuf
auto _testd_nan = _o->testd_nan;
auto _testd_pinf = _o->testd_pinf;
auto _testd_ninf = _o->testd_ninf;
auto _testf_vec = _o->testf_vec.size() ? _fbb.CreateVector(_o->testf_vec) : 0;
auto _testd_vec = _o->testd_vec.size() ? _fbb.CreateVector(_o->testd_vec) : 0;
return MyGame::CreateMonsterExtra(
_fbb,
_testf_nan,
@@ -204,7 +264,9 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBuf
_testf_ninf,
_testd_nan,
_testd_pinf,
_testd_ninf);
_testd_ninf,
_testf_vec,
_testd_vec);
}
inline const flatbuffers::TypeTable *MonsterExtraTypeTable() {
@@ -214,7 +276,9 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() {
{ flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }
{ flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_FLOAT, 1, -1 },
{ flatbuffers::ET_DOUBLE, 1, -1 }
};
static const char * const names[] = {
"testf_nan",
@@ -222,14 +286,69 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() {
"testf_ninf",
"testd_nan",
"testd_pinf",
"testd_ninf"
"testd_ninf",
"testf_vec",
"testd_vec"
};
static const flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, names
flatbuffers::ST_TABLE, 8, type_codes, nullptr, nullptr, names
};
return &tt;
}
inline const MyGame::MonsterExtra *GetMonsterExtra(const void *buf) {
return flatbuffers::GetRoot<MyGame::MonsterExtra>(buf);
}
inline const MyGame::MonsterExtra *GetSizePrefixedMonsterExtra(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf);
}
inline MonsterExtra *GetMutableMonsterExtra(void *buf) {
return flatbuffers::GetMutableRoot<MonsterExtra>(buf);
}
inline const char *MonsterExtraIdentifier() {
return "MONE";
}
inline bool MonsterExtraBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier(
buf, MonsterExtraIdentifier());
}
inline bool VerifyMonsterExtraBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
}
inline bool VerifySizePrefixedMonsterExtraBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
}
inline const char *MonsterExtraExtension() {
return "mon";
}
inline void FinishMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.Finish(root, MonsterExtraIdentifier());
}
inline void FinishSizePrefixedMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.FinishSizePrefixed(root, MonsterExtraIdentifier());
}
inline std::unique_ptr<MonsterExtraT> UnPackMonsterExtra(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<MonsterExtraT>(GetMonsterExtra(buf)->UnPack(res));
}
} // namespace MyGame
#endif // FLATBUFFERS_GENERATED_MONSTEREXTRA_MYGAME_H_