Skip to content

F
flatbuffers
Commit 79f2adc5 authored by Wouter van Oortmerssen's avatar Wouter van Oortmerssen
Browse files
Options

Renamed Verifier methods 

The name Verify was getting too overloaded, and confused
the VS compiler

Change-Id: I26423a4d513e4def2f4e41d7f278bb683fc12518
parent dcfe38c5
Hide whitespace changes
Inline Side-by-side
Showing with 82 additions and 88 deletions
include/flatbuffers/flatbuffers.h
View file @ 79f2adc5
...@@ -1792,27 +1792,28 @@ class Verifier FLATBUFFERS_FINAL_CLASS { ...@@ -1792,27 +1792,28 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
} }
// Verify a pointer (may be NULL) of any vector type. // Verify a pointer (may be NULL) of any vector type.
template<typename T> bool Verify(const Vector<T> *vec) const { template<typename T> bool VerifyVector(const Vector<T> *vec) const {
return !vec || VerifyVector(reinterpret_cast<const uint8_t *>(vec), return !vec || VerifyVectorOrString(reinterpret_cast<const uint8_t *>(vec),
sizeof(T)); sizeof(T));
} }
// Verify a pointer (may be NULL) of a vector to struct. // Verify a pointer (may be NULL) of a vector to struct.
template<typename T> bool Verify(const Vector<const T *> *vec) const { template<typename T> bool VerifyVector(const Vector<const T *> *vec) const {
return Verify(reinterpret_cast<const Vector<T> *>(vec)); return VerifyVector(reinterpret_cast<const Vector<T> *>(vec));
} }
// Verify a pointer (may be NULL) to string. // Verify a pointer (may be NULL) to string.
bool Verify(const String *str) const { bool VerifyString(const String *str) const {
uoffset_t end; uoffset_t end;
return !str || return !str ||
(VerifyVector(reinterpret_cast<const uint8_t *>(str), 1, &end) && (VerifyVectorOrString(reinterpret_cast<const uint8_t *>(str),
1, &end) &&
Verify(end, 1) && // Must have terminator Verify(end, 1) && // Must have terminator
Check(buf_[end] == '\0')); // Terminating byte must be 0. Check(buf_[end] == '\0')); // Terminating byte must be 0.
} }
// Common code between vectors and strings. // Common code between vectors and strings.
bool VerifyVector(const uint8_t *vec, size_t elem_size, bool VerifyVectorOrString(const uint8_t *vec, size_t elem_size,
uoffset_t *end = nullptr) const { uoffset_t *end = nullptr) const {
auto veco = static_cast<uoffset_t>(vec - buf_); auto veco = static_cast<uoffset_t>(vec - buf_);
// Check we can read the size field. // Check we can read the size field.
...@@ -1832,7 +1833,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS { ...@@ -1832,7 +1833,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const { bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const {
if (vec) { if (vec) {
for (uoffset_t i = 0; i < vec->size(); i++) { for (uoffset_t i = 0; i < vec->size(); i++) {
if (!Verify(vec->Get(i))) return false; if (!VerifyString(vec->Get(i))) return false;
} }
} }
return true; return true;
......
include/flatbuffers/reflection_generated.h
View file @ 79f2adc5
...@@ -178,9 +178,9 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -178,9 +178,9 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_KEY) && VerifyOffsetRequired(verifier, VT_KEY) &&
verifier.Verify(key()) && verifier.VerifyString(key()) &&
VerifyOffset(verifier, VT_VALUE) && VerifyOffset(verifier, VT_VALUE) &&
verifier.Verify(value()) && verifier.VerifyString(value()) &&
verifier.EndTable(); verifier.EndTable();
} }
}; };
...@@ -245,14 +245,7 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -245,14 +245,7 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return value() < o->value(); return value() < o->value();
} }
int KeyCompareWithValue(int64_t val) const { int KeyCompareWithValue(int64_t val) const {
const auto key = value(); return static_cast<int>(value() > val) - static_cast<int>(value() < val);
if (key < val) {
return -1;
} else if (key > val) {
return 1;
} else {
return 0;
}
} }
const Object *object() const { const Object *object() const {
return GetPointer<const Object *>(VT_OBJECT); return GetPointer<const Object *>(VT_OBJECT);
...@@ -266,14 +259,14 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -266,14 +259,14 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyField<int64_t>(verifier, VT_VALUE) && VerifyField<int64_t>(verifier, VT_VALUE) &&
VerifyOffset(verifier, VT_OBJECT) && VerifyOffset(verifier, VT_OBJECT) &&
verifier.VerifyTable(object()) && verifier.VerifyTable(object()) &&
VerifyOffset(verifier, VT_UNION_TYPE) && VerifyOffset(verifier, VT_UNION_TYPE) &&
verifier.VerifyTable(union_type()) && verifier.VerifyTable(union_type()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -378,18 +371,18 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -378,18 +371,18 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffsetRequired(verifier, VT_VALUES) && VerifyOffsetRequired(verifier, VT_VALUES) &&
verifier.Verify(values()) && verifier.VerifyVector(values()) &&
verifier.VerifyVectorOfTables(values()) && verifier.VerifyVectorOfTables(values()) &&
VerifyField<uint8_t>(verifier, VT_IS_UNION) && VerifyField<uint8_t>(verifier, VT_IS_UNION) &&
VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) && VerifyOffsetRequired(verifier, VT_UNDERLYING_TYPE) &&
verifier.VerifyTable(underlying_type()) && verifier.VerifyTable(underlying_type()) &&
VerifyOffset(verifier, VT_ATTRIBUTES) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.Verify(attributes()) && verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -523,7 +516,7 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -523,7 +516,7 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffsetRequired(verifier, VT_TYPE) && VerifyOffsetRequired(verifier, VT_TYPE) &&
verifier.VerifyTable(type()) && verifier.VerifyTable(type()) &&
VerifyField<uint16_t>(verifier, VT_ID) && VerifyField<uint16_t>(verifier, VT_ID) &&
...@@ -534,10 +527,10 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -534,10 +527,10 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<uint8_t>(verifier, VT_REQUIRED) && VerifyField<uint8_t>(verifier, VT_REQUIRED) &&
VerifyField<uint8_t>(verifier, VT_KEY) && VerifyField<uint8_t>(verifier, VT_KEY) &&
VerifyOffset(verifier, VT_ATTRIBUTES) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.Verify(attributes()) && verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -689,18 +682,18 @@ struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -689,18 +682,18 @@ struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffsetRequired(verifier, VT_FIELDS) && VerifyOffsetRequired(verifier, VT_FIELDS) &&
verifier.Verify(fields()) && verifier.VerifyVector(fields()) &&
verifier.VerifyVectorOfTables(fields()) && verifier.VerifyVectorOfTables(fields()) &&
VerifyField<uint8_t>(verifier, VT_IS_STRUCT) && VerifyField<uint8_t>(verifier, VT_IS_STRUCT) &&
VerifyField<int32_t>(verifier, VT_MINALIGN) && VerifyField<int32_t>(verifier, VT_MINALIGN) &&
VerifyField<int32_t>(verifier, VT_BYTESIZE) && VerifyField<int32_t>(verifier, VT_BYTESIZE) &&
VerifyOffset(verifier, VT_ATTRIBUTES) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.Verify(attributes()) && verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -816,16 +809,16 @@ struct RPCCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -816,16 +809,16 @@ struct RPCCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffsetRequired(verifier, VT_REQUEST) && VerifyOffsetRequired(verifier, VT_REQUEST) &&
verifier.VerifyTable(request()) && verifier.VerifyTable(request()) &&
VerifyOffsetRequired(verifier, VT_RESPONSE) && VerifyOffsetRequired(verifier, VT_RESPONSE) &&
verifier.VerifyTable(response()) && verifier.VerifyTable(response()) &&
VerifyOffset(verifier, VT_ATTRIBUTES) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.Verify(attributes()) && verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -924,15 +917,15 @@ struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -924,15 +917,15 @@ struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_CALLS) && VerifyOffset(verifier, VT_CALLS) &&
verifier.Verify(calls()) && verifier.VerifyVector(calls()) &&
verifier.VerifyVectorOfTables(calls()) && verifier.VerifyVectorOfTables(calls()) &&
VerifyOffset(verifier, VT_ATTRIBUTES) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
verifier.Verify(attributes()) && verifier.VerifyVector(attributes()) &&
verifier.VerifyVectorOfTables(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
VerifyOffset(verifier, VT_DOCUMENTATION) && VerifyOffset(verifier, VT_DOCUMENTATION) &&
verifier.Verify(documentation()) && verifier.VerifyVector(documentation()) &&
verifier.VerifyVectorOfStrings(documentation()) && verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -1024,19 +1017,19 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -1024,19 +1017,19 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_OBJECTS) && VerifyOffsetRequired(verifier, VT_OBJECTS) &&
verifier.Verify(objects()) && verifier.VerifyVector(objects()) &&
verifier.VerifyVectorOfTables(objects()) && verifier.VerifyVectorOfTables(objects()) &&
VerifyOffsetRequired(verifier, VT_ENUMS) && VerifyOffsetRequired(verifier, VT_ENUMS) &&
verifier.Verify(enums()) && verifier.VerifyVector(enums()) &&
verifier.VerifyVectorOfTables(enums()) && verifier.VerifyVectorOfTables(enums()) &&
VerifyOffset(verifier, VT_FILE_IDENT) && VerifyOffset(verifier, VT_FILE_IDENT) &&
verifier.Verify(file_ident()) && verifier.VerifyString(file_ident()) &&
VerifyOffset(verifier, VT_FILE_EXT) && VerifyOffset(verifier, VT_FILE_EXT) &&
verifier.Verify(file_ext()) && verifier.VerifyString(file_ext()) &&
VerifyOffset(verifier, VT_ROOT_TABLE) && VerifyOffset(verifier, VT_ROOT_TABLE) &&
verifier.VerifyTable(root_table()) && verifier.VerifyTable(root_table()) &&
VerifyOffset(verifier, VT_SERVICES) && VerifyOffset(verifier, VT_SERVICES) &&
verifier.Verify(services()) && verifier.VerifyVector(services()) &&
verifier.VerifyVectorOfTables(services()) && verifier.VerifyVectorOfTables(services()) &&
verifier.EndTable(); verifier.EndTable();
} }
......
samples/monster_generated.h
View file @ 79f2adc5
...@@ -269,12 +269,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -269,12 +269,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int16_t>(verifier, VT_MANA) && VerifyField<int16_t>(verifier, VT_MANA) &&
VerifyField<int16_t>(verifier, VT_HP) && VerifyField<int16_t>(verifier, VT_HP) &&
VerifyOffset(verifier, VT_NAME) && VerifyOffset(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_INVENTORY) && VerifyOffset(verifier, VT_INVENTORY) &&
verifier.Verify(inventory()) && verifier.VerifyVector(inventory()) &&
VerifyField<int8_t>(verifier, VT_COLOR) && VerifyField<int8_t>(verifier, VT_COLOR) &&
VerifyOffset(verifier, VT_WEAPONS) && VerifyOffset(verifier, VT_WEAPONS) &&
verifier.Verify(weapons()) && verifier.VerifyVector(weapons()) &&
verifier.VerifyVectorOfTables(weapons()) && verifier.VerifyVectorOfTables(weapons()) &&
VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE) && VerifyField<uint8_t>(verifier, VT_EQUIPPED_TYPE) &&
VerifyOffset(verifier, VT_EQUIPPED) && VerifyOffset(verifier, VT_EQUIPPED) &&
...@@ -415,7 +415,7 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -415,7 +415,7 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) && VerifyOffset(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyField<int16_t>(verifier, VT_DAMAGE) && VerifyField<int16_t>(verifier, VT_DAMAGE) &&
verifier.EndTable(); verifier.EndTable();
} }
......
src/idl_gen_cpp.cpp
View file @ 79f2adc5
...@@ -1116,7 +1116,7 @@ class CppGenerator : public BaseGenerator { ...@@ -1116,7 +1116,7 @@ class CppGenerator : public BaseGenerator {
} }
} else if (ev.union_type.base_type == BASE_TYPE_STRING) { } else if (ev.union_type.base_type == BASE_TYPE_STRING) {
code_ += getptr; code_ += getptr;
code_ += " return verifier.Verify(ptr);"; code_ += " return verifier.VerifyString(ptr);";
} else { } else {
FLATBUFFERS_ASSERT(false); FLATBUFFERS_ASSERT(false);
} }
...@@ -1503,11 +1503,11 @@ class CppGenerator : public BaseGenerator { ...@@ -1503,11 +1503,11 @@ class CppGenerator : public BaseGenerator {
break; break;
} }
case BASE_TYPE_STRING: { case BASE_TYPE_STRING: {
code_ += "{{PRE}}verifier.Verify({{NAME}}())\\"; code_ += "{{PRE}}verifier.VerifyString({{NAME}}())\\";
break; break;
} }
case BASE_TYPE_VECTOR: { case BASE_TYPE_VECTOR: {
code_ += "{{PRE}}verifier.Verify({{NAME}}())\\"; code_ += "{{PRE}}verifier.VerifyVector({{NAME}}())\\";
switch (field.value.type.element) { switch (field.value.type.element) {
case BASE_TYPE_STRING: { case BASE_TYPE_STRING: {
......
src/reflection.cpp
View file @ 79f2adc5
...@@ -507,7 +507,7 @@ bool VerifyVectorOfStructs(flatbuffers::Verifier &v, ...@@ -507,7 +507,7 @@ bool VerifyVectorOfStructs(flatbuffers::Verifier &v,
auto p = parent_table.GetPointer<const uint8_t *>(field_offset); auto p = parent_table.GetPointer<const uint8_t *>(field_offset);
if (required && !p) { return false; } if (required && !p) { return false; }
return !p || v.VerifyVector(p, obj.bytesize()); return !p || v.VerifyVectorOrString(p, obj.bytesize());
} }
// forward declare to resolve cyclic deps between VerifyObject and VerifyVector // forward declare to resolve cyclic deps between VerifyObject and VerifyVector
...@@ -524,29 +524,29 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema, ...@@ -524,29 +524,29 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema,
switch (vec_field.type()->element()) { switch (vec_field.type()->element()) {
case reflection::None: FLATBUFFERS_ASSERT(false); break; case reflection::None: FLATBUFFERS_ASSERT(false); break;
case reflection::UType: case reflection::UType:
return v.Verify(flatbuffers::GetFieldV<uint8_t>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<uint8_t>(table, vec_field));
case reflection::Bool: case reflection::Bool:
case reflection::Byte: case reflection::Byte:
case reflection::UByte: case reflection::UByte:
return v.Verify(flatbuffers::GetFieldV<int8_t>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<int8_t>(table, vec_field));
case reflection::Short: case reflection::Short:
case reflection::UShort: case reflection::UShort:
return v.Verify(flatbuffers::GetFieldV<int16_t>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<int16_t>(table, vec_field));
case reflection::Int: case reflection::Int:
case reflection::UInt: case reflection::UInt:
return v.Verify(flatbuffers::GetFieldV<int32_t>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<int32_t>(table, vec_field));
case reflection::Long: case reflection::Long:
case reflection::ULong: case reflection::ULong:
return v.Verify(flatbuffers::GetFieldV<int64_t>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<int64_t>(table, vec_field));
case reflection::Float: case reflection::Float:
return v.Verify(flatbuffers::GetFieldV<float>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<float>(table, vec_field));
case reflection::Double: case reflection::Double:
return v.Verify(flatbuffers::GetFieldV<double>(table, vec_field)); return v.VerifyVector(flatbuffers::GetFieldV<double>(table, vec_field));
case reflection::String: { case reflection::String: {
auto vecString = auto vec_string =
flatbuffers::GetFieldV<flatbuffers::Offset<flatbuffers::String>>( flatbuffers::GetFieldV<flatbuffers::Offset<flatbuffers::String>>(
table, vec_field); table, vec_field);
if (v.Verify(vecString) && v.VerifyVectorOfStrings(vecString)) { if (v.VerifyVector(vec_string) && v.VerifyVectorOfStrings(vec_string)) {
return true; return true;
} else { } else {
return false; return false;
...@@ -564,7 +564,7 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema, ...@@ -564,7 +564,7 @@ bool VerifyVector(flatbuffers::Verifier &v, const reflection::Schema &schema,
auto vec = auto vec =
flatbuffers::GetFieldV<flatbuffers::Offset<flatbuffers::Table>>( flatbuffers::GetFieldV<flatbuffers::Offset<flatbuffers::Table>>(
table, vec_field); table, vec_field);
if (!v.Verify(vec)) return false; if (!v.VerifyVector(vec)) return false;
if (vec) { if (vec) {
for (uoffset_t j = 0; j < vec->size(); j++) { for (uoffset_t j = 0; j < vec->size(); j++) {
if (!VerifyObject(v, schema, *obj, vec->Get(j), true)) { if (!VerifyObject(v, schema, *obj, vec->Get(j), true)) {
...@@ -626,7 +626,7 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema, ...@@ -626,7 +626,7 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema,
break; break;
case reflection::String: case reflection::String:
if (!table->VerifyField<uoffset_t>(v, field_def->offset()) || if (!table->VerifyField<uoffset_t>(v, field_def->offset()) ||
!v.Verify(flatbuffers::GetFieldS(*table, *field_def))) { !v.VerifyString(flatbuffers::GetFieldS(*table, *field_def))) {
return false; return false;
} }
break; break;
......
tests/monster_test_generated.h
View file @ 79f2adc5
...@@ -548,7 +548,7 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -548,7 +548,7 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) && VerifyOffset(verifier, VT_ID) &&
verifier.Verify(id()) && verifier.VerifyString(id()) &&
VerifyField<int64_t>(verifier, VT_VAL) && VerifyField<int64_t>(verifier, VT_VAL) &&
VerifyField<uint16_t>(verifier, VT_COUNT) && VerifyField<uint16_t>(verifier, VT_COUNT) &&
verifier.EndTable(); verifier.EndTable();
...@@ -1071,25 +1071,25 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -1071,25 +1071,25 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int16_t>(verifier, VT_MANA) && VerifyField<int16_t>(verifier, VT_MANA) &&
VerifyField<int16_t>(verifier, VT_HP) && VerifyField<int16_t>(verifier, VT_HP) &&
VerifyOffsetRequired(verifier, VT_NAME) && VerifyOffsetRequired(verifier, VT_NAME) &&
verifier.Verify(name()) && verifier.VerifyString(name()) &&
VerifyOffset(verifier, VT_INVENTORY) && VerifyOffset(verifier, VT_INVENTORY) &&
verifier.Verify(inventory()) && verifier.VerifyVector(inventory()) &&
VerifyField<int8_t>(verifier, VT_COLOR) && VerifyField<int8_t>(verifier, VT_COLOR) &&
VerifyField<uint8_t>(verifier, VT_TEST_TYPE) && VerifyField<uint8_t>(verifier, VT_TEST_TYPE) &&
VerifyOffset(verifier, VT_TEST) && VerifyOffset(verifier, VT_TEST) &&
VerifyAny(verifier, test(), test_type()) && VerifyAny(verifier, test(), test_type()) &&
VerifyOffset(verifier, VT_TEST4) && VerifyOffset(verifier, VT_TEST4) &&
verifier.Verify(test4()) && verifier.VerifyVector(test4()) &&
VerifyOffset(verifier, VT_TESTARRAYOFSTRING) && VerifyOffset(verifier, VT_TESTARRAYOFSTRING) &&
verifier.Verify(testarrayofstring()) && verifier.VerifyVector(testarrayofstring()) &&
verifier.VerifyVectorOfStrings(testarrayofstring()) && verifier.VerifyVectorOfStrings(testarrayofstring()) &&
VerifyOffset(verifier, VT_TESTARRAYOFTABLES) && VerifyOffset(verifier, VT_TESTARRAYOFTABLES) &&
verifier.Verify(testarrayoftables()) && verifier.VerifyVector(testarrayoftables()) &&
verifier.VerifyVectorOfTables(testarrayoftables()) && verifier.VerifyVectorOfTables(testarrayoftables()) &&
VerifyOffset(verifier, VT_ENEMY) && VerifyOffset(verifier, VT_ENEMY) &&
verifier.VerifyTable(enemy()) && verifier.VerifyTable(enemy()) &&
VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) && VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
verifier.Verify(testnestedflatbuffer()) && verifier.VerifyVector(testnestedflatbuffer()) &&
VerifyOffset(verifier, VT_TESTEMPTY) && VerifyOffset(verifier, VT_TESTEMPTY) &&
verifier.VerifyTable(testempty()) && verifier.VerifyTable(testempty()) &&
VerifyField<uint8_t>(verifier, VT_TESTBOOL) && VerifyField<uint8_t>(verifier, VT_TESTBOOL) &&
...@@ -1102,40 +1102,40 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -1102,40 +1102,40 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) && VerifyField<int64_t>(verifier, VT_TESTHASHS64_FNV1A) &&
VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) && VerifyField<uint64_t>(verifier, VT_TESTHASHU64_FNV1A) &&
VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) && VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) &&
verifier.Verify(testarrayofbools()) && verifier.VerifyVector(testarrayofbools()) &&
VerifyField<float>(verifier, VT_TESTF) && VerifyField<float>(verifier, VT_TESTF) &&
VerifyField<float>(verifier, VT_TESTF2) && VerifyField<float>(verifier, VT_TESTF2) &&
VerifyField<float>(verifier, VT_TESTF3) && VerifyField<float>(verifier, VT_TESTF3) &&
VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) && VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) &&
verifier.Verify(testarrayofstring2()) && verifier.VerifyVector(testarrayofstring2()) &&
verifier.VerifyVectorOfStrings(testarrayofstring2()) && verifier.VerifyVectorOfStrings(testarrayofstring2()) &&
VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) && VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) &&
verifier.Verify(testarrayofsortedstruct()) && verifier.VerifyVector(testarrayofsortedstruct()) &&
VerifyOffset(verifier, VT_FLEX) && VerifyOffset(verifier, VT_FLEX) &&
verifier.Verify(flex()) && verifier.VerifyVector(flex()) &&
VerifyOffset(verifier, VT_TEST5) && VerifyOffset(verifier, VT_TEST5) &&
verifier.Verify(test5()) && verifier.VerifyVector(test5()) &&
VerifyOffset(verifier, VT_VECTOR_OF_LONGS) && VerifyOffset(verifier, VT_VECTOR_OF_LONGS) &&
verifier.Verify(vector_of_longs()) && verifier.VerifyVector(vector_of_longs()) &&
VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) && VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) &&
verifier.Verify(vector_of_doubles()) && verifier.VerifyVector(vector_of_doubles()) &&
VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) && VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) &&
verifier.VerifyTable(parent_namespace_test()) && verifier.VerifyTable(parent_namespace_test()) &&
VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) && VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) &&
verifier.Verify(vector_of_referrables()) && verifier.VerifyVector(vector_of_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_referrables()) && verifier.VerifyVectorOfTables(vector_of_referrables()) &&
VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) && VerifyField<uint64_t>(verifier, VT_SINGLE_WEAK_REFERENCE) &&
VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) && VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) &&
verifier.Verify(vector_of_weak_references()) && verifier.VerifyVector(vector_of_weak_references()) &&
VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) && VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) &&
verifier.Verify(vector_of_strong_referrables()) && verifier.VerifyVector(vector_of_strong_referrables()) &&
verifier.VerifyVectorOfTables(vector_of_strong_referrables()) && verifier.VerifyVectorOfTables(vector_of_strong_referrables()) &&
VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) && VerifyField<uint64_t>(verifier, VT_CO_OWNING_REFERENCE) &&
VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) && VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) &&
verifier.Verify(vector_of_co_owning_references()) && verifier.VerifyVector(vector_of_co_owning_references()) &&
VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) && VerifyField<uint64_t>(verifier, VT_NON_OWNING_REFERENCE) &&
VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) && VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) &&
verifier.Verify(vector_of_non_owning_references()) && verifier.VerifyVector(vector_of_non_owning_references()) &&
verifier.EndTable(); verifier.EndTable();
} }
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
...@@ -1611,9 +1611,9 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -1611,9 +1611,9 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<float>(verifier, VT_F32) && VerifyField<float>(verifier, VT_F32) &&
VerifyField<double>(verifier, VT_F64) && VerifyField<double>(verifier, VT_F64) &&
VerifyOffset(verifier, VT_V8) && VerifyOffset(verifier, VT_V8) &&
verifier.Verify(v8()) && verifier.VerifyVector(v8()) &&
VerifyOffset(verifier, VT_VF64) && VerifyOffset(verifier, VT_VF64) &&
verifier.Verify(vf64()) && verifier.VerifyVector(vf64()) &&
verifier.EndTable(); verifier.EndTable();
} }
TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
......
tests/union_vector/union_vector_generated.h
View file @ 79f2adc5
...@@ -309,9 +309,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { ...@@ -309,9 +309,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_MAIN_CHARACTER) && VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
VerifyCharacter(verifier, main_character(), main_character_type()) && VerifyCharacter(verifier, main_character(), main_character_type()) &&
VerifyOffset(verifier, VT_CHARACTERS_TYPE) && VerifyOffset(verifier, VT_CHARACTERS_TYPE) &&
verifier.Verify(characters_type()) && verifier.VerifyVector(characters_type()) &&
VerifyOffset(verifier, VT_CHARACTERS) && VerifyOffset(verifier, VT_CHARACTERS) &&
verifier.Verify(characters()) && verifier.VerifyVector(characters()) &&
VerifyCharacterVector(verifier, characters(), characters_type()) && VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable(); verifier.EndTable();
} }
...@@ -458,11 +458,11 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch ...@@ -458,11 +458,11 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
} }
case Character_Other: { case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return verifier.Verify(ptr); return verifier.VerifyString(ptr);
} }
case Character_Unused: { case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return verifier.Verify(ptr); return verifier.VerifyString(ptr);
} }
default: return false; default: return false;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment