vee1e/flatbuffers
1
0
Fork 0
mirror of https://github.com/vee1e/flatbuffers.git synced 2026-09-01 17:57:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Size verifier fix 2 (#8740)

Browse source 
* Fixes to make SizeVerifier work.

In particular change all the places in the Flatbuffers library
and generated code that were using `Verifier` to instead use
`VerifierTemplate<TrackBufferSize>` and wrap them all inside
`template <bool TrackBufferSize = false>`.

Also add unit tests for SizeVerifier.

* Format using `sh scripts/clang-format-git.sh`

* Use `B` rather than `TrackBufferSize` for the name of the template parameter.

* Update generated files.
This commit is contained in:
Fergus Henderson 2025-11-24 12:11:32 +00:00 • committed by GitHub
parent 7ea8db05d8
commit 20548ff3b6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
30 changed files with 588 additions and 305 deletions
Download patch file Download diff file Expand all files Collapse all files

71
tests/cpp17/generated_cpp17/monster_test_generated.h
View file

@ -323,8 +323,10 @@ struct AnyUnion {
}
};
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<Any> *types);
template <bool B = false>
bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
template <bool B = false>
bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
enum class AnyUniqueAliases : uint8_t {
NONE = 0,
@ -450,8 +452,10 @@ struct AnyUniqueAliasesUnion {
}
};
bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
template <bool B = false>
bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
template <bool B = false>
bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
enum class AnyAmbiguousAliases : uint8_t {
NONE = 0,
@ -535,8 +539,10 @@ struct AnyAmbiguousAliasesUnion {
}
};
bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
template <bool B = false>
bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
template <bool B = false>
bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
private:
@ -881,7 +887,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return InParentNamespaceTypeTable();
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
@ -935,7 +942,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MonsterTypeTable();
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
@ -1006,7 +1014,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
if constexpr (Index == 0) return color();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
verifier.EndTable();
@ -1107,7 +1116,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
else if constexpr (Index == 2) return count();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyString(id()) &&
@ -1218,7 +1228,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
if constexpr (Index == 0) return id();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ID, 8) &&
verifier.EndTable();
@ -1886,7 +1897,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
else if constexpr (Index == 60) return double_inf_default();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@ -1911,7 +1923,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
verifier.VerifyTable(enemy()) &&
VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
verifier.VerifyVector(testnestedflatbuffer()) &&
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
VerifyOffset(verifier, VT_TESTEMPTY) &&
verifier.VerifyTable(testempty()) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@ -1970,7 +1982,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
verifier.VerifyVector(testrequirednestedflatbuffer()) &&
verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
verifier.VerifyVector(scalar_key_sorted_tables()) &&
verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@ -2692,7 +2704,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
else if constexpr (Index == 11) return vf64();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_I8, 1) &&
VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@ -3385,7 +3398,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
_vf64);
}
inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
template <bool B>
inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
switch (type) {
case Any::NONE: {
return true;
@ -3406,7 +3420,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
}
}
inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
template <bool B>
inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@ -3498,7 +3513,8 @@ inline void AnyUnion::Reset() {
type = Any::NONE;
}
inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
template <bool B>
inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
switch (type) {
case AnyUniqueAliases::NONE: {
return true;
@ -3519,7 +3535,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
}
}
inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
template <bool B>
inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@ -3611,7 +3628,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
type = AnyUniqueAliases::NONE;
}
inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
template <bool B>
inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
switch (type) {
case AnyAmbiguousAliases::NONE: {
return true;
@ -3632,7 +3650,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
}
}
inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
template <bool B>
inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@ -4241,14 +4260,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
buf, MonsterIdentifier(), true);
}
template <bool B = false>
inline bool VerifyMonsterBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
}
template <bool B = false>
inline bool VerifySizePrefixedMonsterBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
}
inline const char *MonsterExtension() {

13
tests/cpp17/generated_cpp17/optional_scalars_generated.h
View file

@ -395,7 +395,8 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
else if constexpr (Index == 35) return default_enum();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@ -958,14 +959,16 @@ inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
buf, ScalarStuffIdentifier(), true);
}
template <bool B = false>
inline bool VerifyScalarStuffBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
template <bool B = false>
inline bool VerifySizePrefixedScalarStuffBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
}
inline const char *ScalarStuffExtension() {

51
tests/cpp17/generated_cpp17/union_vector_generated.h
View file

@ -158,8 +158,10 @@ struct CharacterUnion {
}
};
bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
template <bool B = false>
bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type);
template <bool B = false>
bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
enum class Gadget : uint8_t {
NONE = 0,
@ -266,8 +268,10 @@ struct GadgetUnion {
}
};
bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
template <bool B = false>
bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type);
template <bool B = false>
bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private:
@ -418,7 +422,8 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
if constexpr (Index == 0) return sword_attack_damage();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable();
@ -495,7 +500,8 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
if constexpr (Index == 0) return length();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable();
@ -612,7 +618,8 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
else if constexpr (Index == 3) return characters();
else static_assert(Index != -1, "Invalid Field Index");
}
bool Verify(::flatbuffers::Verifier &verifier) const {
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@ -791,7 +798,8 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
_characters);
}
inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
template <bool B>
inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type) {
switch (type) {
case Character::NONE: {
return true;
@ -801,13 +809,13 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
return verifier.VerifyTable(ptr);
}
case Character::Rapunzel: {
return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
return verifier.template VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::Belle: {
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::BookFan: {
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Character::Other: {
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
@ -821,7 +829,8 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
}
}
inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
template <bool B>
inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@ -964,13 +973,14 @@ inline void CharacterUnion::Reset() {
type = Character::NONE;
}
inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
template <bool B>
inline bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type) {
switch (type) {
case Gadget::NONE: {
return true;
}
case Gadget::FallingTub: {
return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
return verifier.template VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
}
case Gadget::HandFan: {
auto ptr = reinterpret_cast<const HandFan *>(obj);
@ -980,7 +990,8 @@ inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gad
}
}
inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
template <bool B>
inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false;
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@ -1226,14 +1237,16 @@ inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
buf, MovieIdentifier(), true);
}
template <bool B = false>
inline bool VerifyMovieBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Movie>(MovieIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifyBuffer<Movie>(MovieIdentifier());
}
template <bool B = false>
inline bool VerifySizePrefixedMovieBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
::flatbuffers::VerifierTemplate<B> &verifier) {
return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
}
inline void FinishMovieBuffer(