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

added support for parsing hash on vector elements (#4502)

Browse Source 
* added support for parsing hash on vector elements

reversed check for scalar to check for vector

added C++ generation of cpp_type vectors

removed ctor call for vector fields
added condition !vector for cpp_type check

added Pack() and UnPack() code generation for vector of hashes

* schema change:
added table Referrable and weak references towards it from Monster

added single_weak_reference to Monster table
changed order with vector_of_weak_references

* re-generated monster schema dependent code

added Referrable.cs to FlatBuffers.Test.csproj
This commit is contained in:
Christian Helmich
2018-02-23 04:04:26 +09:00
committed by Wouter van Oortmerssen
parent 132e6a8220
commit 59e26017cb
13 changed files with 971 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
tests/monster_test_generated.h
View File

@@ -33,6 +33,9 @@ struct Ability;
struct Stat;
struct StatT;
struct Referrable;
struct ReferrableT;
struct Monster;
struct MonsterT;
@@ -604,6 +607,76 @@ inline flatbuffers::Offset<Stat> CreateStatDirect(
flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ReferrableT : public flatbuffers::NativeTable {
typedef Referrable TableType;
uint64_t id;
ReferrableT()
: id(0) {
}
};
struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReferrableT NativeTableType;
enum {
VT_ID = 4
};
uint64_t id() const {
return GetField<uint64_t>(VT_ID, 0);
}
bool mutate_id(uint64_t _id) {
return SetField<uint64_t>(VT_ID, _id, 0);
}
bool KeyCompareLessThan(const Referrable *o) const {
return id() < o->id();
}
int KeyCompareWithValue(uint64_t val) const {
const auto key = id();
if (key < val) {
return -1;
} else if (key > val) {
return 1;
} else {
return 0;
}
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ID) &&
verifier.EndTable();
}
ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Referrable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ReferrableBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_id(uint64_t id) {
fbb_.AddElement<uint64_t>(Referrable::VT_ID, id, 0);
}
explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReferrableBuilder &operator=(const ReferrableBuilder &);
flatbuffers::Offset<Referrable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Referrable>(end);
return o;
}
};
inline flatbuffers::Offset<Referrable> CreateReferrable(
flatbuffers::FlatBufferBuilder &_fbb,
uint64_t id = 0) {
ReferrableBuilder builder_(_fbb);
builder_.add_id(id);
return builder_.Finish();
}
flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MonsterT : public flatbuffers::NativeTable {
typedef Monster TableType;
flatbuffers::unique_ptr<Vec3> pos;
@@ -639,6 +712,9 @@ struct MonsterT : public flatbuffers::NativeTable {
std::vector<int64_t> vector_of_longs;
std::vector<double> vector_of_doubles;
flatbuffers::unique_ptr<MyGame::InParentNamespaceT> parent_namespace_test;
std::vector<flatbuffers::unique_ptr<ReferrableT>> vector_of_referrables;
ReferrableT *single_weak_reference;
std::vector<ReferrableT*> vector_of_weak_references;
MonsterT()
: mana(150),
hp(100),
@@ -654,7 +730,8 @@ struct MonsterT : public flatbuffers::NativeTable {
testhashu64_fnv1a(0),
testf(3.14159f),
testf2(3.0f),
testf3(0.0f) {
testf3(0.0f),
single_weak_reference(0) {
}
};
@@ -698,7 +775,10 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_TEST5 = 66,
VT_VECTOR_OF_LONGS = 68,
VT_VECTOR_OF_DOUBLES = 70,
VT_PARENT_NAMESPACE_TEST = 72
VT_PARENT_NAMESPACE_TEST = 72,
VT_VECTOR_OF_REFERRABLES = 74,
VT_SINGLE_WEAK_REFERENCE = 76,
VT_VECTOR_OF_WEAK_REFERENCES = 78
};
const Vec3 *pos() const {
return GetStruct<const Vec3 *>(VT_POS);
@@ -929,6 +1009,24 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
MyGame::InParentNamespace *mutable_parent_namespace_test() {
return GetPointer<MyGame::InParentNamespace *>(VT_PARENT_NAMESPACE_TEST);
}
const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *vector_of_referrables() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
}
flatbuffers::Vector<flatbuffers::Offset<Referrable>> *mutable_vector_of_referrables() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<Referrable>> *>(VT_VECTOR_OF_REFERRABLES);
}
uint64_t single_weak_reference() const {
return GetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, 0);
}
bool mutate_single_weak_reference(uint64_t _single_weak_reference) {
return SetField<uint64_t>(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0);
}
const flatbuffers::Vector<uint64_t> *vector_of_weak_references() const {
return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
}
flatbuffers::Vector<uint64_t> *mutable_vector_of_weak_references() {
return GetPointer<flatbuffers::Vector<uint64_t> *>(VT_VECTOR_OF_WEAK_REFERENCES);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<Vec3>(verifier, VT_POS) &&
@@ -985,6 +1083,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.Verify(vector_of_doubles()) &&
VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
verifier.VerifyTable(parent_namespace_test()) &&
VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
verifier.Verify(vector_of_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_referrables()) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) &&
VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
verifier.Verify(vector_of_weak_references()) &&
verifier.EndTable();
}
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1109,6 +1213,15 @@ struct MonsterBuilder {
void add_parent_namespace_test(flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test) {
fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test);
}
void add_vector_of_referrables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables) {
fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables);
}
void add_single_weak_reference(uint64_t single_weak_reference) {
fbb_.AddElement<uint64_t>(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0);
}
void add_vector_of_weak_references(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references) {
fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references);
}
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -1157,12 +1270,18 @@ inline flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::Offset<flatbuffers::Vector<const Test *>> test5 = 0,
flatbuffers::Offset<flatbuffers::Vector<int64_t>> vector_of_longs = 0,
flatbuffers::Offset<flatbuffers::Vector<double>> vector_of_doubles = 0,
flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0) {
flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Referrable>>> vector_of_referrables = 0,
uint64_t single_weak_reference = 0,
flatbuffers::Offset<flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0) {
MonsterBuilder builder_(_fbb);
builder_.add_single_weak_reference(single_weak_reference);
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_vector_of_weak_references(vector_of_weak_references);
builder_.add_vector_of_referrables(vector_of_referrables);
builder_.add_parent_namespace_test(parent_namespace_test);
builder_.add_vector_of_doubles(vector_of_doubles);
builder_.add_vector_of_longs(vector_of_longs);
@@ -1231,7 +1350,10 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
const std::vector<Test> *test5 = nullptr,
const std::vector<int64_t> *vector_of_longs = nullptr,
const std::vector<double> *vector_of_doubles = nullptr,
flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0) {
flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
const std::vector<flatbuffers::Offset<Referrable>> *vector_of_referrables = nullptr,
uint64_t single_weak_reference = 0,
const std::vector<uint64_t> *vector_of_weak_references = nullptr) {
return MyGame::Example::CreateMonster(
_fbb,
pos,
@@ -1267,7 +1389,10 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
test5 ? _fbb.CreateVectorOfStructs<Test>(*test5) : 0,
vector_of_longs ? _fbb.CreateVector<int64_t>(*vector_of_longs) : 0,
vector_of_doubles ? _fbb.CreateVector<double>(*vector_of_doubles) : 0,
parent_namespace_test);
parent_namespace_test,
vector_of_referrables ? _fbb.CreateVector<flatbuffers::Offset<Referrable>>(*vector_of_referrables) : 0,
single_weak_reference,
vector_of_weak_references ? _fbb.CreateVector<uint64_t>(*vector_of_weak_references) : 0);
}
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -1639,6 +1764,32 @@ inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb
_count);
}
inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReferrableT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = id(); _o->id = _e; };
}
inline flatbuffers::Offset<Referrable> Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateReferrable(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Referrable> CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _id = _o->id;
return MyGame::Example::CreateReferrable(
_fbb,
_id);
}
inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MonsterT();
UnPackTo(_o, _resolver);
@@ -1682,6 +1833,9 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } };
{ auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } };
{ auto _e = parent_namespace_test(); if (_e) _o->parent_namespace_test = flatbuffers::unique_ptr<MyGame::InParentNamespaceT>(_e->UnPack(_resolver)); };
{ auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr<ReferrableT>(_e->Get(_i)->UnPack(_resolver)); } } };
{ auto _e = single_weak_reference(); if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->single_weak_reference), static_cast<flatbuffers::hash_value_t>(_e)); else _o->single_weak_reference = nullptr; };
{ auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_weak_references[_i]), static_cast<flatbuffers::hash_value_t>(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } };
}
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -1726,6 +1880,9 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<flatbuffers::Offset<Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0;
return MyGame::Example::CreateMonster(
_fbb,
_pos,
@@ -1761,7 +1918,10 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
_test5,
_vector_of_longs,
_vector_of_doubles,
_parent_namespace_test);
_parent_namespace_test,
_vector_of_referrables,
_single_weak_reference,
_vector_of_weak_references);
}
inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -1934,6 +2094,34 @@ inline void AnyUnion::Reset() {
type = Any_NONE;
}
} // namespace Example
inline flatbuffers::TypeTable *InParentNamespaceTypeTable();
namespace Example2 {
inline flatbuffers::TypeTable *MonsterTypeTable();
} // namespace Example2
namespace Example {
inline flatbuffers::TypeTable *TestTypeTable();
inline flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable();
inline flatbuffers::TypeTable *Vec3TypeTable();
inline flatbuffers::TypeTable *AbilityTypeTable();
inline flatbuffers::TypeTable *StatTypeTable();
inline flatbuffers::TypeTable *ReferrableTypeTable();
inline flatbuffers::TypeTable *MonsterTypeTable();
inline flatbuffers::TypeTable *TypeAliasesTypeTable();
inline flatbuffers::TypeTable *ColorTypeTable() {
static flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 },
@@ -2094,6 +2282,19 @@ inline flatbuffers::TypeTable *StatTypeTable() {
return &tt;
}
inline flatbuffers::TypeTable *ReferrableTypeTable() {
static flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_ULONG, 0, -1 }
};
static const char *names[] = {
"id"
};
static flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, names
};
return &tt;
}
inline flatbuffers::TypeTable *MonsterTypeTable() {
static flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 },
@@ -2130,7 +2331,10 @@ inline flatbuffers::TypeTable *MonsterTypeTable() {
{ flatbuffers::ET_SEQUENCE, 1, 3 },
{ flatbuffers::ET_LONG, 1, -1 },
{ flatbuffers::ET_DOUBLE, 1, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 7 }
{ flatbuffers::ET_SEQUENCE, 0, 7 },
{ flatbuffers::ET_SEQUENCE, 1, 8 },
{ flatbuffers::ET_ULONG, 0, -1 },
{ flatbuffers::ET_ULONG, 1, -1 }
};
static flatbuffers::TypeFunction type_refs[] = {
Vec3TypeTable,
@@ -2140,7 +2344,8 @@ inline flatbuffers::TypeTable *MonsterTypeTable() {
MonsterTypeTable,
StatTypeTable,
AbilityTypeTable,
MyGame::InParentNamespaceTypeTable
MyGame::InParentNamespaceTypeTable,
ReferrableTypeTable
};
static const char *names[] = {
"pos",
@@ -2177,10 +2382,13 @@ inline flatbuffers::TypeTable *MonsterTypeTable() {
"test5",
"vector_of_longs",
"vector_of_doubles",
"parent_namespace_test"
"parent_namespace_test",
"vector_of_referrables",
"single_weak_reference",
"vector_of_weak_references"
};
static flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 35, type_codes, type_refs, nullptr, names
flatbuffers::ST_TABLE, 38, type_codes, type_refs, nullptr, names
};
return &tt;
}