From cc8424009853447b209c5d3ccb12c23a2f134fa4 Mon Sep 17 00:00:00 2001
From: Wouter van Oortmerssen <aardappel@gmail.com>
Date: Wed, 4 Jan 2017 10:12:39 -0800
Subject: [PATCH] Misc idl_gen_cpp cleanup
- Update to be const-correct where possible.
- Consistently pass |code| as pointer instead of non-const-ref.
- No newlines (\n) characters in the middle of code strings.
- Use if-else if-else statements instead of nested ternary operators.
- Ensure all lines end at 80 chars.
- Make utility functions static.
From cl/143505731.
Change-Id: If0fab9ee75de5af963367a948dddf53af93f73b4
---
include/flatbuffers/code_generators.h | 30 +-
include/flatbuffers/reflection_generated.h | 140 +++-
samples/monster_generated.h | 46 +-
src/idl_gen_cpp.cpp | 662 ++++++++++--------
src/idl_gen_general.cpp | 2 +-
tests/monster_test_generated.h | 134 +++-
.../namespace_test1_generated.h | 4 +-
.../namespace_test2_generated.h | 24 +-
8 files changed, 645 insertions(+), 397 deletions(-)
diff --git a/include/flatbuffers/code_generators.h b/include/flatbuffers/code_generators.h
index 8b097ef7..5bd2219f 100644
--- a/include/flatbuffers/code_generators.h
+++ b/include/flatbuffers/code_generators.h
@@ -23,9 +23,9 @@ class BaseGenerator {
public:
virtual bool generate() = 0;
- static const std::string NamespaceDir(const Parser &parser,
- const std::string &path,
- const Namespace &ns) {
+ static std::string NamespaceDir(const Parser &parser,
+ const std::string &path,
+ const Namespace &ns) {
EnsureDirExists(path.c_str());
if (parser.opts.one_file) return path;
std::string namespace_dir = path; // Either empty or ends in separator.
@@ -46,14 +46,14 @@ class BaseGenerator {
path_(path),
file_name_(file_name),
qualifying_start_(qualifying_start),
- qualifying_separator_(qualifying_separator){};
- virtual ~BaseGenerator(){};
+ qualifying_separator_(qualifying_separator) {}
+ virtual ~BaseGenerator() {}
// No copy/assign.
BaseGenerator &operator=(const BaseGenerator &);
BaseGenerator(const BaseGenerator &);
- const std::string NamespaceDir(const Namespace &ns) {
+ std::string NamespaceDir(const Namespace &ns) const {
return BaseGenerator::NamespaceDir(parser_, path_, ns);
}
@@ -62,7 +62,7 @@ class BaseGenerator {
" do not modify\n\n";
}
- bool IsEverythingGenerated() {
+ bool IsEverythingGenerated() const {
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
if (!(*it)->generated) return false;
@@ -74,7 +74,7 @@ class BaseGenerator {
return true;
}
- std::string FullNamespace(const char *separator, const Namespace &ns) {
+ static std::string FullNamespace(const char *separator, const Namespace &ns) {
std::string namespace_name;
auto &namespaces = ns.components;
for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
@@ -84,10 +84,9 @@ class BaseGenerator {
return namespace_name;
}
- const std::string LastNamespacePart(const Namespace &ns) {
- auto &namespaces = ns.components;
- if (namespaces.size())
- return *(namespaces.end() - 1);
+ static std::string LastNamespacePart(const Namespace &ns) {
+ if (!ns.components.empty())
+ return ns.components.back();
else
return std::string("");
}
@@ -96,11 +95,12 @@ class BaseGenerator {
// c++, java and csharp returns a different namespace from
// the following default (no early exit, always fully qualify),
// which works for js and php
- virtual const Namespace *CurrentNameSpace() { return nullptr; }
+ virtual const Namespace *CurrentNameSpace() const { return nullptr; }
// Ensure that a type is prefixed with its namespace whenever it is used
// outside of its namespace.
- std::string WrapInNameSpace(const Namespace *ns, const std::string &name) {
+ std::string WrapInNameSpace(const Namespace *ns,
+ const std::string &name) const {
if (CurrentNameSpace() == ns) return name;
std::string qualified_name = qualifying_start_;
for (auto it = ns->components.begin(); it != ns->components.end(); ++it)
@@ -108,7 +108,7 @@ class BaseGenerator {
return qualified_name + name;
}
- std::string WrapInNameSpace(const Definition &def) {
+ std::string WrapInNameSpace(const Definition &def) const {
return WrapInNameSpace(def.defined_namespace, def.name);
}
diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h
index b6233ff0..5a810b70 100644
--- a/include/flatbuffers/reflection_generated.h
+++ b/include/flatbuffers/reflection_generated.h
@@ -69,9 +69,15 @@ struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TypeBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_base_type(BaseType base_type) { fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0); }
- void add_element(BaseType element) { fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0); }
- void add_index(int32_t index) { fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1); }
+ void add_base_type(BaseType base_type) {
+ fbb_.AddElement<int8_t>(Type::VT_BASE_TYPE, static_cast<int8_t>(base_type), 0);
+ }
+ void add_element(BaseType element) {
+ fbb_.AddElement<int8_t>(Type::VT_ELEMENT, static_cast<int8_t>(element), 0);
+ }
+ void add_index(int32_t index) {
+ fbb_.AddElement<int32_t>(Type::VT_INDEX, index, -1);
+ }
TypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
TypeBuilder &operator=(const TypeBuilder &);
flatbuffers::Offset<Type> Finish() {
@@ -113,8 +119,12 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct KeyValueBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_key(flatbuffers::Offset<flatbuffers::String> key) { fbb_.AddOffset(KeyValue::VT_KEY, key); }
- void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(KeyValue::VT_VALUE, value); }
+ void add_key(flatbuffers::Offset<flatbuffers::String> key) {
+ fbb_.AddOffset(KeyValue::VT_KEY, key);
+ }
+ void add_value(flatbuffers::Offset<flatbuffers::String> value) {
+ fbb_.AddOffset(KeyValue::VT_VALUE, value);
+ }
KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
KeyValueBuilder &operator=(const KeyValueBuilder &);
flatbuffers::Offset<KeyValue> Finish() {
@@ -164,9 +174,15 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct EnumValBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(EnumVal::VT_NAME, name); }
- void add_value(int64_t value) { fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0); }
- void add_object(flatbuffers::Offset<Object> object) { fbb_.AddOffset(EnumVal::VT_OBJECT, object); }
+ void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ fbb_.AddOffset(EnumVal::VT_NAME, name);
+ }
+ void add_value(int64_t value) {
+ fbb_.AddElement<int64_t>(EnumVal::VT_VALUE, value, 0);
+ }
+ void add_object(flatbuffers::Offset<Object> object) {
+ fbb_.AddOffset(EnumVal::VT_OBJECT, object);
+ }
EnumValBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
EnumValBuilder &operator=(const EnumValBuilder &);
flatbuffers::Offset<EnumVal> Finish() {
@@ -229,11 +245,21 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct EnumBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Enum::VT_NAME, name); }
- void add_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<EnumVal>>> values) { fbb_.AddOffset(Enum::VT_VALUES, values); }
- void add_is_union(bool is_union) { fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0); }
- void add_underlying_type(flatbuffers::Offset<Type> underlying_type) { fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type); }
- void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes); }
+ void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ fbb_.AddOffset(Enum::VT_NAME, name);
+ }
+ void add_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<EnumVal>>> values) {
+ fbb_.AddOffset(Enum::VT_VALUES, values);
+ }
+ void add_is_union(bool is_union) {
+ fbb_.AddElement<uint8_t>(Enum::VT_IS_UNION, static_cast<uint8_t>(is_union), 0);
+ }
+ void add_underlying_type(flatbuffers::Offset<Type> underlying_type) {
+ fbb_.AddOffset(Enum::VT_UNDERLYING_TYPE, underlying_type);
+ }
+ void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) {
+ fbb_.AddOffset(Enum::VT_ATTRIBUTES, attributes);
+ }
EnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
EnumBuilder &operator=(const EnumBuilder &);
flatbuffers::Offset<Enum> Finish() {
@@ -317,16 +343,36 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct FieldBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Field::VT_NAME, name); }
- void add_type(flatbuffers::Offset<Type> type) { fbb_.AddOffset(Field::VT_TYPE, type); }
- void add_id(uint16_t id) { fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0); }
- void add_offset(uint16_t offset) { fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0); }
- void add_default_integer(int64_t default_integer) { fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0); }
- void add_default_real(double default_real) { fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0); }
- void add_deprecated(bool deprecated) { fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0); }
- void add_required(bool required) { fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0); }
- void add_key(bool key) { fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0); }
- void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes); }
+ void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ fbb_.AddOffset(Field::VT_NAME, name);
+ }
+ void add_type(flatbuffers::Offset<Type> type) {
+ fbb_.AddOffset(Field::VT_TYPE, type);
+ }
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(Field::VT_ID, id, 0);
+ }
+ void add_offset(uint16_t offset) {
+ fbb_.AddElement<uint16_t>(Field::VT_OFFSET, offset, 0);
+ }
+ void add_default_integer(int64_t default_integer) {
+ fbb_.AddElement<int64_t>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
+ }
+ void add_default_real(double default_real) {
+ fbb_.AddElement<double>(Field::VT_DEFAULT_REAL, default_real, 0.0);
+ }
+ void add_deprecated(bool deprecated) {
+ fbb_.AddElement<uint8_t>(Field::VT_DEPRECATED, static_cast<uint8_t>(deprecated), 0);
+ }
+ void add_required(bool required) {
+ fbb_.AddElement<uint8_t>(Field::VT_REQUIRED, static_cast<uint8_t>(required), 0);
+ }
+ void add_key(bool key) {
+ fbb_.AddElement<uint8_t>(Field::VT_KEY, static_cast<uint8_t>(key), 0);
+ }
+ void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) {
+ fbb_.AddOffset(Field::VT_ATTRIBUTES, attributes);
+ }
FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
FieldBuilder &operator=(const FieldBuilder &);
flatbuffers::Offset<Field> Finish() {
@@ -413,12 +459,24 @@ struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ObjectBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Object::VT_NAME, name); }
- void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields) { fbb_.AddOffset(Object::VT_FIELDS, fields); }
- void add_is_struct(bool is_struct) { fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0); }
- void add_minalign(int32_t minalign) { fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0); }
- void add_bytesize(int32_t bytesize) { fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0); }
- void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) { fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes); }
+ void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ fbb_.AddOffset(Object::VT_NAME, name);
+ }
+ void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields) {
+ fbb_.AddOffset(Object::VT_FIELDS, fields);
+ }
+ void add_is_struct(bool is_struct) {
+ fbb_.AddElement<uint8_t>(Object::VT_IS_STRUCT, static_cast<uint8_t>(is_struct), 0);
+ }
+ void add_minalign(int32_t minalign) {
+ fbb_.AddElement<int32_t>(Object::VT_MINALIGN, minalign, 0);
+ }
+ void add_bytesize(int32_t bytesize) {
+ fbb_.AddElement<int32_t>(Object::VT_BYTESIZE, bytesize, 0);
+ }
+ void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) {
+ fbb_.AddOffset(Object::VT_ATTRIBUTES, attributes);
+ }
ObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ObjectBuilder &operator=(const ObjectBuilder &);
flatbuffers::Offset<Object> Finish() {
@@ -490,11 +548,21 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct SchemaBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Object>>> objects) { fbb_.AddOffset(Schema::VT_OBJECTS, objects); }
- void add_enums(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Enum>>> enums) { fbb_.AddOffset(Schema::VT_ENUMS, enums); }
- void add_file_ident(flatbuffers::Offset<flatbuffers::String> file_ident) { fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident); }
- void add_file_ext(flatbuffers::Offset<flatbuffers::String> file_ext) { fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext); }
- void add_root_table(flatbuffers::Offset<Object> root_table) { fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table); }
+ void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Object>>> objects) {
+ fbb_.AddOffset(Schema::VT_OBJECTS, objects);
+ }
+ void add_enums(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Enum>>> enums) {
+ fbb_.AddOffset(Schema::VT_ENUMS, enums);
+ }
+ void add_file_ident(flatbuffers::Offset<flatbuffers::String> file_ident) {
+ fbb_.AddOffset(Schema::VT_FILE_IDENT, file_ident);
+ }
+ void add_file_ext(flatbuffers::Offset<flatbuffers::String> file_ext) {
+ fbb_.AddOffset(Schema::VT_FILE_EXT, file_ext);
+ }
+ void add_root_table(flatbuffers::Offset<Object> root_table) {
+ fbb_.AddOffset(Schema::VT_ROOT_TABLE, root_table);
+ }
SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
SchemaBuilder &operator=(const SchemaBuilder &);
flatbuffers::Offset<Schema> Finish() {
@@ -545,7 +613,9 @@ inline bool VerifySchemaBuffer(flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());
}
-inline const char *SchemaExtension() { return "bfbs"; }
+inline const char *SchemaExtension() {
+ return "bfbs";
+}
inline void FinishSchemaBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<reflection::Schema> root) {
fbb.Finish(root, SchemaIdentifier());
diff --git a/samples/monster_generated.h b/samples/monster_generated.h
index 6c7b3059..cbd8ee68 100644
--- a/samples/monster_generated.h
+++ b/samples/monster_generated.h
@@ -56,7 +56,7 @@ template<> struct EquipmentTraits<Weapon> {
struct EquipmentUnion {
Equipment type;
- flatbuffers::NativeTable *table;
+ flatbuffers::NativeTable *table = nullptr;
EquipmentUnion() : type(Equipment_NONE), table(nullptr) {}
EquipmentUnion(const EquipmentUnion &);
EquipmentUnion &operator=(const EquipmentUnion &);
@@ -173,15 +173,33 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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), 2); }
- void add_weapons(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Weapon>>> weapons) { fbb_.AddOffset(Monster::VT_WEAPONS, weapons); }
- void add_equipped_type(Equipment equipped_type) { fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0); }
- void add_equipped(flatbuffers::Offset<void> equipped) { fbb_.AddOffset(Monster::VT_EQUIPPED, equipped); }
+ 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), 2);
+ }
+ void add_weapons(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Weapon>>> weapons) {
+ fbb_.AddOffset(Monster::VT_WEAPONS, weapons);
+ }
+ void add_equipped_type(Equipment equipped_type) {
+ fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0);
+ }
+ void add_equipped(flatbuffers::Offset<void> equipped) {
+ fbb_.AddOffset(Monster::VT_EQUIPPED, equipped);
+ }
MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
MonsterBuilder &operator=(const MonsterBuilder &);
flatbuffers::Offset<Monster> Finish() {
@@ -260,8 +278,12 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct WeaponBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(Weapon::VT_NAME, name); }
- void add_damage(int16_t damage) { fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0); }
+ void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ fbb_.AddOffset(Weapon::VT_NAME, name);
+ }
+ void add_damage(int16_t damage) {
+ fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0);
+ }
WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
WeaponBuilder &operator=(const WeaponBuilder &);
flatbuffers::Offset<Weapon> Finish() {
diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index 5154b85d..65f13550 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -23,10 +23,6 @@
namespace flatbuffers {
-struct IsAlnum {
- bool operator()(char c) { return !isalnum(c); }
-};
-
static std::string GeneratedFileName(const std::string &path,
const std::string &file_name) {
return path + file_name + "_generated.h";
@@ -38,51 +34,62 @@ class CppGenerator : public BaseGenerator {
CppGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
: BaseGenerator(parser, path, file_name, "", "::"),
- cur_name_space_(nullptr){};
- // Iterate through all definitions we haven't generate code for (enums,
- // structs,
- // and tables) and output them to a single file.
- bool generate() {
- if (IsEverythingGenerated()) return true;
-
- std::string code;
- code = code + "// " + FlatBuffersGeneratedWarning();
+ cur_name_space_(nullptr) {}
+ std::string GenIncludeGuard() const {
// Generate include guard.
- std::string include_guard_ident = file_name_;
+ std::string guard = file_name_;
// Remove any non-alpha-numeric characters that may appear in a filename.
- include_guard_ident.erase(
- std::remove_if(include_guard_ident.begin(), include_guard_ident.end(),
- IsAlnum()),
- include_guard_ident.end());
- std::string include_guard = "FLATBUFFERS_GENERATED_" + include_guard_ident;
- include_guard += "_";
+ struct IsAlnum {
+ bool operator()(char c) { return !isalnum(c); }
+ };
+ guard.erase(std::remove_if(guard.begin(), guard.end(), IsAlnum()),
+ guard.end());
+ guard = "FLATBUFFERS_GENERATED_" + guard;
+ guard += "_";
// For further uniqueness, also add the namespace.
auto name_space = parser_.namespaces_.back();
for (auto it = name_space->components.begin();
it != name_space->components.end(); ++it) {
- include_guard += *it + "_";
+ guard += *it + "_";
}
- include_guard += "H_";
- std::transform(include_guard.begin(), include_guard.end(),
- include_guard.begin(), ::toupper);
+ guard += "H_";
+ std::transform(guard.begin(), guard.end(), guard.begin(), ::toupper);
+ return guard;
+ }
+
+ void GenIncludeDependencies(std::string* code_ptr) const {
+ std::string& code = *code_ptr;
+
+ int num_includes = 0;
+ for (auto it = parser_.included_files_.begin();
+ it != parser_.included_files_.end(); ++it) {
+ const std::string basename =
+ flatbuffers::StripPath(flatbuffers::StripExtension(it->first));
+ if (basename != file_name_) {
+ code += "#include \"" + basename + "_generated.h\"\n";
+ num_includes++;
+ }
+ }
+ if (num_includes) code += "\n";
+ }
+
+ // Iterate through all definitions we haven't generate code for (enums,
+ // structs, and tables) and output them to a single file.
+ bool generate() {
+ if (IsEverythingGenerated()) return true;
+
+ std::string code;
+ code = code + "// " + FlatBuffersGeneratedWarning();
+
+ const std::string include_guard = GenIncludeGuard();
code += "#ifndef " + include_guard + "\n";
code += "#define " + include_guard + "\n\n";
code += "#include \"flatbuffers/flatbuffers.h\"\n\n";
if (parser_.opts.include_dependence_headers) {
- int num_includes = 0;
- for (auto it = parser_.included_files_.begin();
- it != parser_.included_files_.end(); ++it) {
- auto basename =
- flatbuffers::StripPath(flatbuffers::StripExtension(it->first));
- if (basename != file_name_) {
- code += "#include \"" + basename + "_generated.h\"\n";
- num_includes++;
- }
- }
- if (num_includes) code += "\n";
+ GenIncludeDependencies(&code);
}
assert(!cur_name_space_);
@@ -91,7 +98,7 @@ class CppGenerator : public BaseGenerator {
// have circular references.
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
- auto &struct_def = **it;
+ const auto &struct_def = **it;
if (!struct_def.generated) {
SetNameSpace(struct_def.defined_namespace, &code);
code += "struct " + struct_def.name + ";\n";
@@ -105,17 +112,17 @@ class CppGenerator : public BaseGenerator {
// Generate code for all the enum declarations.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
- auto &enum_def = **it;
+ const auto &enum_def = **it;
if (!enum_def.generated) {
- SetNameSpace((**it).defined_namespace, &code);
- GenEnum(**it, &code);
+ SetNameSpace(enum_def.defined_namespace, &code);
+ GenEnum(enum_def, &code);
}
}
// Generate code for all structs, then all tables.
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
- auto &struct_def = **it;
+ const auto &struct_def = **it;
if (struct_def.fixed && !struct_def.generated) {
SetNameSpace(struct_def.defined_namespace, &code);
GenStruct(struct_def, &code);
@@ -123,7 +130,7 @@ class CppGenerator : public BaseGenerator {
}
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
- auto &struct_def = **it;
+ const auto &struct_def = **it;
if (!struct_def.fixed && !struct_def.generated) {
SetNameSpace(struct_def.defined_namespace, &code);
GenTable(struct_def, &code);
@@ -131,7 +138,7 @@ class CppGenerator : public BaseGenerator {
}
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
- auto &struct_def = **it;
+ const auto &struct_def = **it;
if (!struct_def.fixed && !struct_def.generated) {
SetNameSpace(struct_def.defined_namespace, &code);
GenTablePost(struct_def, &code);
@@ -141,7 +148,7 @@ class CppGenerator : public BaseGenerator {
// Generate code for union verifiers.
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
- auto &enum_def = **it;
+ const auto &enum_def = **it;
if (enum_def.is_union && !enum_def.generated) {
SetNameSpace(enum_def.defined_namespace, &code);
GenUnionPost(enum_def, &code);
@@ -151,64 +158,64 @@ class CppGenerator : public BaseGenerator {
// Generate convenient global helper functions:
if (parser_.root_struct_def_) {
SetNameSpace((*parser_.root_struct_def_).defined_namespace, &code);
- auto &name = parser_.root_struct_def_->name;
- std::string qualified_name =
+ const std::string &name = parser_.root_struct_def_->name;
+ const std::string qualified_name =
parser_.namespaces_.back()->GetFullyQualifiedName(name);
- std::string cpp_qualified_name = TranslateNameSpace(qualified_name);
+ const std::string cpp_name = TranslateNameSpace(qualified_name);
// The root datatype accessor:
- code += "inline const " + cpp_qualified_name + " *Get";
- code += name;
- code += "(const void *buf) {\n return flatbuffers::GetRoot<";
- code += cpp_qualified_name + ">(buf);\n}\n\n";
+ code += "inline ";
+ code += "const " + cpp_name + " *Get" + name + "(const void *buf) {\n";
+ code += " return flatbuffers::GetRoot<" + cpp_name + ">(buf);\n";
+ code += "}\n\n";
+
if (parser_.opts.mutable_buffer) {
- code += "inline " + name + " *GetMutable";
- code += name;
- code += "(void *buf) {\n return flatbuffers::GetMutableRoot<";
- code += name + ">(buf);\n}\n\n";
+ code += "inline " + name + " *GetMutable" + name + "(void *buf) {\n";
+ code += " return flatbuffers::GetMutableRoot<" + name + ">(buf);\n";
+ code += "}\n\n";
}
if (parser_.file_identifier_.length()) {
// Return the identifier
- code += "inline const char *" + name;
- code += "Identifier() {\n return \"" + parser_.file_identifier_;
- code += "\";\n}\n\n";
+ code += "inline const char *" + name + "Identifier() {\n";
+ code += " return \"" + parser_.file_identifier_ + "\";\n";
+ code += "}\n\n";
// Check if a buffer has the identifier.
- code += "inline bool " + name;
- code += "BufferHasIdentifier(const void *buf) {\n return flatbuffers::";
- code += "BufferHasIdentifier(buf, ";
- code += name + "Identifier());\n}\n\n";
+ code += "inline ";
+ code += "bool " + name + "BufferHasIdentifier(const void *buf) {\n";
+ code += " return flatbuffers::BufferHasIdentifier(buf, ";
+ code += name + "Identifier());\n";
+ code += "}\n\n";
}
- // The root verifier:
- code += "inline bool Verify";
- code += name;
- code +=
- "Buffer(flatbuffers::Verifier &verifier) {\n"
- " return verifier.VerifyBuffer<";
- code += cpp_qualified_name + ">(";
+ // The root verifier.
+ code += "inline bool Verify" + name + "Buffer(";
+ code += "flatbuffers::Verifier &verifier) {\n";
+ code += " return verifier.VerifyBuffer<" + cpp_name + ">(";
if (parser_.file_identifier_.length())
code += name + "Identifier()";
else
code += "nullptr";
- code += ");\n}\n\n";
+ code += ");\n";
+ code += "}\n\n";
if (parser_.file_extension_.length()) {
// Return the extension
- code += "inline const char *" + name;
- code += "Extension() { return \"" + parser_.file_extension_;
- code += "\"; }\n\n";
+ code += "inline const char *" + name + "Extension() {\n";
+ code += " return \"" + parser_.file_extension_ + "\";\n";
+ code += "}\n\n";
}
// Finish a buffer with a given root object:
- code += "inline void Finish" + name;
- code +=
- "Buffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<";
- code += cpp_qualified_name + "> root) {\n fbb.Finish(root";
+ code += "inline void Finish" + name + "Buffer";
+ code += "(flatbuffers::FlatBufferBuilder &fbb, ";
+ code += "flatbuffers::Offset<" + cpp_name + "> root) {\n";
if (parser_.file_identifier_.length())
- code += ", " + name + "Identifier()";
- code += ");\n}\n\n";
+ code += " fbb.Finish(root, " + name + "Identifier());\n";
+ else
+ code += " fbb.Finish(root);\n";
+ code += "}\n\n";
if (parser_.opts.generate_object_based_api) {
// A convenient root unpack function.
@@ -217,9 +224,11 @@ class CppGenerator : public BaseGenerator {
code += "inline " + GenTypeNativePtr(native_name, nullptr, false);
code += " UnPack" + name;
code += "(const void *buf, const flatbuffers::resolver_function_t *";
- code += "resolver = nullptr) {\n return ";
+ code += "resolver = nullptr) {\n";
+ code += " return ";
code += GenTypeNativePtr(native_name, nullptr, true);
- code += "(Get" + name + "(buf)->UnPack(resolver));\n}\n\n";
+ code += "(Get" + name + "(buf)->UnPack(resolver));\n";
+ code += "}\n\n";
}
}
@@ -236,7 +245,7 @@ class CppGenerator : public BaseGenerator {
// This tracks the current namespace so we can insert namespace declarations.
const Namespace *cur_name_space_;
- const Namespace *CurrentNameSpace() { return cur_name_space_; }
+ const Namespace *CurrentNameSpace() const { return cur_name_space_; }
// Translates a qualified name in flatbuffer text format to the same name in
// the equivalent C++ namespace.
@@ -251,7 +260,7 @@ class CppGenerator : public BaseGenerator {
}
// Return a C++ type from the table in idl.h
- std::string GenTypeBasic(const Type &type, bool user_facing_type) {
+ std::string GenTypeBasic(const Type &type, bool user_facing_type) const {
static const char *ctypename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \
#CTYPE,
@@ -267,43 +276,53 @@ class CppGenerator : public BaseGenerator {
// Return a C++ pointer type, specialized to the actual struct/table types,
// and vector element types.
- std::string GenTypePointer(const Type &type) {
+ std::string GenTypePointer(const Type &type) const {
switch (type.base_type) {
- case BASE_TYPE_STRING:
+ case BASE_TYPE_STRING: {
return "flatbuffers::String";
- case BASE_TYPE_VECTOR:
- return "flatbuffers::Vector<" +
- GenTypeWire(type.VectorType(), "", false) + ">";
- case BASE_TYPE_STRUCT:
+ }
+ case BASE_TYPE_VECTOR: {
+ const auto type_name = GenTypeWire(type.VectorType(), "", false);
+ return "flatbuffers::Vector<" + type_name + ">";
+ }
+ case BASE_TYPE_STRUCT: {
return WrapInNameSpace(*type.struct_def);
+ }
case BASE_TYPE_UNION:
// fall through
- default:
+ default: {
return "void";
+ }
}
}
// Return a C++ type for any type (scalar/pointer) specifically for
// building a flatbuffer.
std::string GenTypeWire(const Type &type, const char *postfix,
- bool user_facing_type) {
- return IsScalar(type.base_type)
- ? GenTypeBasic(type, user_facing_type) + postfix
- : IsStruct(type) ? "const " + GenTypePointer(type) + " *"
- : "flatbuffers::Offset<" +
- GenTypePointer(type) + ">" + postfix;
+ bool user_facing_type) const {
+ if (IsScalar(type.base_type)) {
+ return GenTypeBasic(type, user_facing_type) + postfix;
+ } else if (IsStruct(type)) {
+ return "const " + GenTypePointer(type) + " *";
+ } else {
+ return "flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix;
+ }
}
// Return a C++ type for any type (scalar/pointer) that reflects its
// serialized size.
- std::string GenTypeSize(const Type &type) {
- return IsScalar(type.base_type) ? GenTypeBasic(type, false)
- : IsStruct(type) ? GenTypePointer(type)
- : "flatbuffers::uoffset_t";
+ std::string GenTypeSize(const Type &type) const {
+ if (IsScalar(type.base_type)) {
+ return GenTypeBasic(type, false);
+ } else if (IsStruct(type)) {
+ return GenTypePointer(type);
+ } else {
+ return "flatbuffers::uoffset_t";
+ }
}
// TODO(wvo): make this configurable.
- std::string NativeName(const std::string &name) { return name + "T"; }
+ static std::string NativeName(const std::string &name) { return name + "T"; }
const std::string &PtrType(const FieldDef *field) {
auto attr = field ? field->attributes.Lookup("cpp_ptr_type") : nullptr;
@@ -313,8 +332,13 @@ class CppGenerator : public BaseGenerator {
std::string GenTypeNativePtr(const std::string &type, const FieldDef *field,
bool is_constructor) {
auto &ptr_type = PtrType(field);
- if (ptr_type == "naked") return is_constructor ? "" : type + " *";
- return ptr_type + "<" + type + ">";
+ if (ptr_type != "naked") {
+ return ptr_type + "<" + type + ">";
+ } else if (is_constructor) {
+ return "";
+ } else {
+ return type + " *";
+ }
}
std::string GenPtrGet(const FieldDef &field) {
@@ -325,27 +349,31 @@ class CppGenerator : public BaseGenerator {
std::string GenTypeNative(const Type &type, bool invector,
const FieldDef &field) {
switch (type.base_type) {
- case BASE_TYPE_STRING:
+ case BASE_TYPE_STRING: {
return "std::string";
- case BASE_TYPE_VECTOR:
- return "std::vector<" + GenTypeNative(type.VectorType(), true, field) +
- ">";
- case BASE_TYPE_STRUCT:
+ }
+ case BASE_TYPE_VECTOR: {
+ const auto type_name = GenTypeNative(type.VectorType(), true, field);
+ return "std::vector<" + type_name + ">";
+ }
+ case BASE_TYPE_STRUCT: {
+ const auto type_name = WrapInNameSpace(*type.struct_def);
if (IsStruct(type)) {
if (invector || field.native_inline) {
- return WrapInNameSpace(*type.struct_def);
+ return type_name;
} else {
- return GenTypeNativePtr(WrapInNameSpace(*type.struct_def), &field,
- false);
+ return GenTypeNativePtr(type_name, &field, false);
}
} else {
- return GenTypeNativePtr(NativeName(WrapInNameSpace(*type.struct_def)),
- &field, false);
+ return GenTypeNativePtr(NativeName(type_name), &field, false);
}
- case BASE_TYPE_UNION:
+ }
+ case BASE_TYPE_UNION: {
return type.enum_def->name + "Union";
- default:
+ }
+ default: {
return GenTypeBasic(type, true);
+ }
}
}
@@ -354,25 +382,27 @@ class CppGenerator : public BaseGenerator {
std::string GenTypeGet(const Type &type, const char *afterbasic,
const char *beforeptr, const char *afterptr,
bool user_facing_type) {
- return IsScalar(type.base_type)
- ? GenTypeBasic(type, user_facing_type) + afterbasic
- : beforeptr + GenTypePointer(type) + afterptr;
+ if (IsScalar(type.base_type)) {
+ return GenTypeBasic(type, user_facing_type) + afterbasic;
+ } else {
+ return beforeptr + GenTypePointer(type) + afterptr;
+ }
}
- static std::string GenEnumDecl(const EnumDef &enum_def,
- const IDLOptions &opts) {
+ std::string GenEnumDecl(const EnumDef &enum_def) const {
+ const IDLOptions &opts = parser_.opts;
return (opts.scoped_enums ? "enum class " : "enum ") + enum_def.name;
}
- static std::string GenEnumValDecl(const EnumDef &enum_def,
- const std::string &enum_val,
- const IDLOptions &opts) {
+ std::string GenEnumValDecl(const EnumDef &enum_def,
+ const std::string &enum_val) const {
+ const IDLOptions &opts = parser_.opts;
return opts.prefixed_enums ? enum_def.name + "_" + enum_val : enum_val;
}
- static std::string GetEnumValUse(const EnumDef &enum_def,
- const EnumVal &enum_val,
- const IDLOptions &opts) {
+ std::string GetEnumValUse(const EnumDef &enum_def,
+ const EnumVal &enum_val) const {
+ const IDLOptions &opts = parser_.opts;
if (opts.scoped_enums) {
return enum_def.name + "::" + enum_val.name;
} else if (opts.prefixed_enums) {
@@ -382,13 +412,14 @@ class CppGenerator : public BaseGenerator {
}
}
- std::string UnionVerifySignature(EnumDef &enum_def) {
+ static std::string UnionVerifySignature(const EnumDef &enum_def) {
return "inline bool Verify" + enum_def.name +
"(flatbuffers::Verifier &verifier, const void *union_obj, " +
enum_def.name + " type)";
}
- std::string UnionUnPackSignature(EnumDef &enum_def, bool inclass) {
+ static std::string UnionUnPackSignature(const EnumDef &enum_def,
+ bool inclass) {
return (inclass ? "static " : "") +
std::string("flatbuffers::NativeTable *") +
(inclass ? "" : enum_def.name + "Union::") +
@@ -396,7 +427,7 @@ class CppGenerator : public BaseGenerator {
" type, const flatbuffers::resolver_function_t *resolver)";
}
- std::string UnionPackSignature(EnumDef &enum_def, bool inclass) {
+ static std::string UnionPackSignature(const EnumDef &enum_def, bool inclass) {
return "flatbuffers::Offset<void> " +
(inclass ? "" : enum_def.name + "Union::") +
"Pack(flatbuffers::FlatBufferBuilder &_fbb, " +
@@ -404,7 +435,8 @@ class CppGenerator : public BaseGenerator {
(inclass ? " = nullptr" : "") + ") const";
}
- std::string TableCreateSignature(StructDef &struct_def, bool predecl) {
+ static std::string TableCreateSignature(const StructDef &struct_def,
+ bool predecl) {
return "inline flatbuffers::Offset<" + struct_def.name + "> Create" +
struct_def.name +
"(flatbuffers::FlatBufferBuilder &_fbb, const " +
@@ -413,7 +445,8 @@ class CppGenerator : public BaseGenerator {
(predecl ? " = nullptr" : "") + ")";
}
- std::string TablePackSignature(StructDef &struct_def, bool inclass) {
+ static std::string TablePackSignature(const StructDef &struct_def,
+ bool inclass) {
return std::string(inclass ? "static " : "") +
"flatbuffers::Offset<" + struct_def.name + "> " +
(inclass ? "" : struct_def.name + "::") +
@@ -423,7 +456,8 @@ class CppGenerator : public BaseGenerator {
(inclass ? " = nullptr" : "") + ")";
}
- std::string TableUnPackSignature(StructDef &struct_def, bool inclass) {
+ static std::string TableUnPackSignature(const StructDef &struct_def,
+ bool inclass) {
return NativeName(struct_def.name) + " *" +
(inclass ? "" : struct_def.name + "::") +
"UnPack(const flatbuffers::resolver_function_t *resolver" +
@@ -431,20 +465,20 @@ class CppGenerator : public BaseGenerator {
}
// Generate an enum declaration and an enum string lookup table.
- void GenEnum(EnumDef &enum_def, std::string *code_ptr) {
+ void GenEnum(const EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr;
GenComment(enum_def.doc_comment, code_ptr, nullptr);
- code += GenEnumDecl(enum_def, parser_.opts);
+ code += GenEnumDecl(enum_def);
if (parser_.opts.scoped_enums)
code += " : " + GenTypeBasic(enum_def.underlying_type, false);
code += " {\n";
int64_t anyv = 0;
- EnumVal *minv = nullptr, *maxv = nullptr;
+ const EnumVal *minv = nullptr, *maxv = nullptr;
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
+ const auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, " ");
- code += " " + GenEnumValDecl(enum_def, ev.name, parser_.opts) + " = ";
+ code += " " + GenEnumValDecl(enum_def, ev.name) + " = ";
code += NumToString(ev.value);
if (it != enum_def.vals.vec.end() - 1) code += ",\n";
minv = !minv || minv->value > ev.value ? &ev : minv;
@@ -455,18 +489,23 @@ class CppGenerator : public BaseGenerator {
assert(minv && maxv);
if (enum_def.attributes.Lookup("bit_flags")) {
if (minv->value != 0) // If the user didn't defined NONE value
- code += ",\n " + GenEnumValDecl(enum_def, "NONE", parser_.opts) + " = 0";
+ code += ",\n";
+ code += " " + GenEnumValDecl(enum_def, "NONE") + " = 0";
if (maxv->value != anyv) // If the user didn't defined ANY value
- code += ",\n " + GenEnumValDecl(enum_def, "ANY", parser_.opts) + " = " +
+ code += ",\n";
+ code += " " + GenEnumValDecl(enum_def, "ANY") + " = " +
NumToString(anyv);
} else { // MIN & MAX are useless for bit_flags
- code += ",\n " + GenEnumValDecl(enum_def, "MIN", parser_.opts) + " = ";
- code += GenEnumValDecl(enum_def, minv->name, parser_.opts);
- code += ",\n " + GenEnumValDecl(enum_def, "MAX", parser_.opts) + " = ";
- code += GenEnumValDecl(enum_def, maxv->name, parser_.opts);
+ code += ",\n";
+ code += " " + GenEnumValDecl(enum_def, "MIN") + " = ";
+ code += GenEnumValDecl(enum_def, minv->name);
+ code += ",\n";
+ code += " " + GenEnumValDecl(enum_def, "MAX") + " = ";
+ code += GenEnumValDecl(enum_def, maxv->name);
}
}
- code += "\n};\n";
+ code += "\n";
+ code += "};\n";
if (parser_.opts.scoped_enums && enum_def.attributes.Lookup("bit_flags"))
code += "DEFINE_BITMASK_OPERATORS(" + enum_def.name + ", " +
GenTypeBasic(enum_def.underlying_type, false) + ")\n";
@@ -488,17 +527,19 @@ class CppGenerator : public BaseGenerator {
auto val = enum_def.vals.vec.front()->value;
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- while (val++ != (*it)->value) code += "\"\", ";
- code += "\"" + (*it)->name + "\", ";
+ const auto &ev = **it;
+ while (val++ != ev.value) code += "\"\", ";
+ code += "\"" + ev.name + "\", ";
}
- code += "nullptr };\n return names;\n}\n\n";
+ code += "nullptr };\n";
+ code += " return names;\n";
+ code += "}\n\n";
code += "inline const char *EnumName" + enum_def.name;
code += "(" + enum_def.name + " e) { return EnumNames" + enum_def.name;
code += "()[static_cast<int>(e)";
if (enum_def.vals.vec.front()->value) {
code += " - static_cast<int>(";
- code += GetEnumValUse(enum_def, *enum_def.vals.vec.front(), parser_.opts) +
- ")";
+ code += GetEnumValUse(enum_def, *enum_def.vals.vec.front()) + ")";
}
code += "]; }\n\n";
}
@@ -508,7 +549,7 @@ class CppGenerator : public BaseGenerator {
for (auto it = enum_def.vals.vec.begin();
it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
+ const auto &ev = **it;
if (it == enum_def.vals.vec.begin()) {
code += "template<typename T> struct " + enum_def.name + "Traits {\n";
}
@@ -517,7 +558,7 @@ class CppGenerator : public BaseGenerator {
WrapInNameSpace(*ev.struct_def) + "> {\n";
}
code += " static const " + enum_def.name + " enum_value = " +
- GetEnumValUse(enum_def, ev, parser_.opts) + ";\n";
+ GetEnumValUse(enum_def, ev) + ";\n";
code += "};\n\n";
}
}
@@ -526,9 +567,9 @@ class CppGenerator : public BaseGenerator {
// Generate a union type
code += "struct " + enum_def.name + "Union {\n";
code += " " + enum_def.name + " type;\n\n";
- code += " flatbuffers::NativeTable *table;\n";
+ code += " flatbuffers::NativeTable *table = nullptr;\n";
code += " " + enum_def.name + "Union() : type(";
- code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"), parser_.opts);
+ code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"));
code += "), table(nullptr) {}\n";
code += " " + enum_def.name + "Union(const ";
code += enum_def.name + "Union &);\n";
@@ -536,13 +577,14 @@ class CppGenerator : public BaseGenerator {
code += enum_def.name + "Union &);\n";
code += " ~" + enum_def.name + "Union() { Reset(); }\n";
code += " void Reset();\n\n";
+
code += " template <typename T>\n";
code += " void Set(T&& value) {\n";
code += " Reset();\n";
code += " type = " + enum_def.name;
code += "Traits<typename T::TableType>::enum_value;\n";
code += " if (type != ";
- code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"), parser_.opts);
+ code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"));
code += ") {\n";
code += " table = new T(std::forward<T>(value));\n";
code += " }\n";
@@ -551,12 +593,12 @@ class CppGenerator : public BaseGenerator {
code += " " + UnionPackSignature(enum_def, true) + ";\n\n";
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
+ const auto &ev = **it;
if (ev.value) {
auto native_name = NativeName(WrapInNameSpace(*ev.struct_def));
code += " " + native_name + " *As";
code += ev.name + "() { return type == ";
- code += GetEnumValUse(enum_def, ev, parser_.opts);
+ code += GetEnumValUse(enum_def, ev);
code += " ? reinterpret_cast<" + native_name;
code += " *>(table) : nullptr; }\n";
}
@@ -569,18 +611,19 @@ class CppGenerator : public BaseGenerator {
}
}
- void GenUnionPost(EnumDef &enum_def, std::string *code_ptr) {
+ void GenUnionPost(const EnumDef &enum_def, std::string *code_ptr) {
// Generate a verifier function for this union that can be called by the
// table verifier functions. It uses a switch case to select a specific
// verifier function to call, this should be safe even if the union type
// has been corrupted, since the verifiers will simply fail when called
// on the wrong type.
std::string &code = *code_ptr;
- code += UnionVerifySignature(enum_def) + " {\n switch (type) {\n";
+ code += UnionVerifySignature(enum_def) + " {\n";
+ code += " switch (type) {\n";
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
- code += " case " + GetEnumValUse(enum_def, ev, parser_.opts);
+ const auto &ev = **it;
+ code += " case " + GetEnumValUse(enum_def, ev);
if (!ev.value) {
code += ": return true;\n"; // "NONE" enum value.
} else {
@@ -589,16 +632,19 @@ class CppGenerator : public BaseGenerator {
code += " *>(union_obj));\n";
}
}
- code += " default: return false;\n }\n}\n\n";
+ code += " default: return false;\n";
+ code += " }\n";
+ code += "}\n\n";
if (parser_.opts.generate_object_based_api) {
// Generate a union pack & unpack function.
code += "inline " + UnionUnPackSignature(enum_def, false);
- code += " {\n switch (type) {\n";
+ code += " {\n";
+ code += " switch (type) {\n";
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
- code += " case " + GetEnumValUse(enum_def, ev, parser_.opts);
+ const auto &ev = **it;
+ code += " case " + GetEnumValUse(enum_def, ev);
if (!ev.value) {
code += ": return nullptr;\n"; // "NONE" enum value.
} else {
@@ -607,13 +653,15 @@ class CppGenerator : public BaseGenerator {
code += " *>(union_obj)->UnPack(resolver);\n";
}
}
- code += " default: return nullptr;\n }\n}\n\n";
- code += "inline " + UnionPackSignature(enum_def, false);
- code += " {\n switch (type) {\n";
+ code += " default: return nullptr;\n";
+ code += " }\n";
+ code += "}\n\n";
+ code += "inline " + UnionPackSignature(enum_def, false) + " {\n";
+ code += " switch (type) {\n";
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
auto &ev = **it;
- code += " case " + GetEnumValUse(enum_def, ev, parser_.opts);
+ code += " case " + GetEnumValUse(enum_def, ev);
if (!ev.value) {
code += ": return 0;\n"; // "NONE" enum value.
} else {
@@ -623,16 +671,18 @@ class CppGenerator : public BaseGenerator {
code += " *>(table), rehasher).Union();\n";
}
}
- code += " default: return 0;\n }\n}\n\n";
+ code += " default: return 0;\n";
+ code += " }\n";
+ code += "}\n\n";
// Generate a union destructor.
code += "inline void " + enum_def.name + "Union::Reset() {\n";
code += " switch (type) {\n";
for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
++it) {
- auto &ev = **it;
+ const auto &ev = **it;
if (ev.value) {
- code += " case " + GetEnumValUse(enum_def, ev, parser_.opts);
+ code += " case " + GetEnumValUse(enum_def, ev);
code += ": delete reinterpret_cast<";
code += NativeName(WrapInNameSpace(*ev.struct_def));
code += " *>(table); break;\n";
@@ -642,7 +692,7 @@ class CppGenerator : public BaseGenerator {
code += " }\n";
code += " table = nullptr;\n";
code += " type = ";
- code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"), parser_.opts);
+ code += GetEnumValUse(enum_def, *enum_def.vals.Lookup("NONE"));
code += ";\n";
code += "}\n\n";
}
@@ -672,7 +722,9 @@ class CppGenerator : public BaseGenerator {
return "VT_" + uname;
}
- void GenFullyQualifiedNameGetter(const std::string &name, std::string &code) {
+ void GenFullyQualifiedNameGetter(const std::string &name,
+ std::string *code_ptr) {
+ std::string &code = *code_ptr;
if (parser_.opts.generate_name_strings) {
code +=
" static FLATBUFFERS_CONSTEXPR const char *GetFullyQualifiedName() "
@@ -696,7 +748,7 @@ class CppGenerator : public BaseGenerator {
if (ev) {
return WrapInNameSpace(
field.value.type.enum_def->defined_namespace,
- GetEnumValUse(*field.value.type.enum_def, *ev, parser_.opts));
+ GetEnumValUse(*field.value.type.enum_def, *ev));
} else {
return GenUnderlyingCast(field, true, field.value.constant);
}
@@ -707,13 +759,16 @@ class CppGenerator : public BaseGenerator {
}
}
- void GenSimpleParam(std::string &code, FieldDef &field) {
- code += ",\n " + GenTypeWire(field.value.type, " ", true);
+ void GenSimpleParam(const FieldDef &field, std::string *code_ptr) {
+ std::string &code = *code_ptr;
+ code += ",\n";
+ code += " " + GenTypeWire(field.value.type, " ", true);
code += field.name + " = " + GetDefaultScalarValue(field);
}
// Generate a member, including a default value for scalars and raw pointers.
- void GenMember(std::string& code, const FieldDef &field) {
+ void GenMember(const FieldDef &field, std::string *code_ptr) {
+ std::string &code = *code_ptr;
if (!field.deprecated && // Deprecated fields won't be accessible.
field.value.type.base_type != BASE_TYPE_UTYPE) {
auto type = GenTypeNative(field.value.type, false, field);
@@ -725,12 +780,14 @@ class CppGenerator : public BaseGenerator {
// Generate the default constructor for this struct. Properly initialize all
// scalar members with default values.
- void GenDefaultConstructor(std::string& code, const StructDef& struct_def) {
+ void GenDefaultConstructor(const StructDef& struct_def,
+ std::string *code_ptr) {
+ std::string &code = *code_ptr;
code += " " + NativeName(struct_def.name) + "()";
std::string initializer_list;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated && // Deprecated fields won't be accessible.
field.value.type.base_type != BASE_TYPE_UTYPE) {
auto cpp_type = field.attributes.Lookup("cpp_type");
@@ -739,24 +796,26 @@ class CppGenerator : public BaseGenerator {
if (!initializer_list.empty()) {
initializer_list += ",\n ";
}
- initializer_list += field.name + "(" +GetDefaultScalarValue(field) +
- ")";
+ initializer_list += field.name;
+ initializer_list += "(" + GetDefaultScalarValue(field) + ")";
} else if (cpp_type) {
if (!initializer_list.empty()) {
- code += ",\n ";
+ code += ",\n";
+ code += " ";
}
initializer_list += field.name + "(0)";
}
}
}
if (!initializer_list.empty()) {
- code += "\n : " + initializer_list;
+ code += "\n";
+ code += " : " + initializer_list;
}
code += " {}\n";
}
// Generate an accessor struct, builder structs & function for a table.
- void GenTable(StructDef &struct_def, std::string *code_ptr) {
+ void GenTable(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
if (parser_.opts.generate_object_based_api) {
@@ -766,13 +825,13 @@ class CppGenerator : public BaseGenerator {
code += " : public flatbuffers::NativeTable {\n";
code += " typedef " + struct_def.name + " TableType;\n";
// Generate GetFullyQualifiedName
- GenFullyQualifiedNameGetter(NativeName(struct_def.name), code);
+ GenFullyQualifiedNameGetter(NativeName(struct_def.name), &code);
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
- GenMember(code, field);
+ const auto &field = **it;
+ GenMember(field, &code);
}
- GenDefaultConstructor(code, struct_def);
+ GenDefaultConstructor(struct_def, &code);
code += "};\n\n";
}
@@ -787,7 +846,7 @@ class CppGenerator : public BaseGenerator {
" NativeTableType;\n";
}
// Generate GetFullyQualifiedName
- GenFullyQualifiedNameGetter(struct_def.name, code);
+ GenFullyQualifiedNameGetter(struct_def.name, &code);
// Generate field id constants.
if (struct_def.fields.vec.size() > 0) {
code += " enum {\n";
@@ -795,7 +854,7 @@ class CppGenerator : public BaseGenerator {
true; // track the first field that's not deprecated
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) { // Deprecated fields won't be accessible.
if (!is_first_field) {
// Add trailing comma and newline to previous element. Don't add
@@ -809,12 +868,13 @@ class CppGenerator : public BaseGenerator {
code += NumToString(field.value.offset);
}
}
- code += "\n };\n";
+ code += "\n";
+ code += " };\n";
}
// Generate the accessors.
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) { // Deprecated fields won't be accessible.
auto is_scalar = IsScalar(field.value.type.base_type);
GenComment(field.doc_comment, code_ptr, nullptr, " ");
@@ -897,7 +957,7 @@ class CppGenerator : public BaseGenerator {
std::string prefix = " &&\n ";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
code += prefix + "VerifyField";
if (field.required) code += "Required";
@@ -944,7 +1004,8 @@ class CppGenerator : public BaseGenerator {
}
}
code += prefix + "verifier.EndTable()";
- code += ";\n }\n";
+ code += ";\n";
+ code += " }\n";
if (parser_.opts.generate_object_based_api) {
// Generate the UnPack() pre declaration.
@@ -955,31 +1016,35 @@ class CppGenerator : public BaseGenerator {
code += "};\n\n"; // End of table.
// Generate a builder struct, with methods of the form:
- // void add_name(type name) { fbb_.AddElement<type>(offset, name, default);
+ // void add_name(type name) {
+ // fbb_.AddElement<type>(offset, name, default);
// }
- code += "struct " + struct_def.name;
- code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n";
+ code += "struct " + struct_def.name + "Builder {\n";
+ code += " flatbuffers::FlatBufferBuilder &fbb_;\n";
code += " flatbuffers::uoffset_t start_;\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
code += " void add_" + field.name + "(";
code += GenTypeWire(field.value.type, " ", true) + field.name;
- code += ") { fbb_.Add";
+ code += ") {\n";
+
+ code += " fbb_.Add";
if (IsScalar(field.value.type.base_type)) {
- code += "Element<" + GenTypeWire(field.value.type, "", false);
- code += ">";
+ code += "Element<" + GenTypeWire(field.value.type, "", false) + ">";
} else if (IsStruct(field.value.type)) {
code += "Struct";
} else {
code += "Offset";
}
+
code += "(" + struct_def.name + "::" + GenFieldOffsetName(field) + ", ";
code += GenUnderlyingCast(field, false, field.name);
if (IsScalar(field.value.type.base_type))
code += ", " + GenDefaultConstant(field);
- code += "); }\n";
+ code += ");\n";
+ code += " }\n";
}
}
code += " " + struct_def.name;
@@ -988,19 +1053,22 @@ class CppGenerator : public BaseGenerator {
code += " " + struct_def.name + "Builder &operator=(const ";
code += struct_def.name + "Builder &);\n";
code += " flatbuffers::Offset<" + struct_def.name;
- code += "> Finish() {\n auto o = flatbuffers::Offset<" + struct_def.name;
+ code += "> Finish() {\n";
+ code += " auto o = flatbuffers::Offset<" + struct_def.name;
code += ">(fbb_.EndTable(start_, ";
code += NumToString(struct_def.fields.vec.size()) + "));\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated && field.required) {
code += " fbb_.Required(o, ";
code += struct_def.name + "::" + GenFieldOffsetName(field);
code += "); // " + field.name + "\n";
}
}
- code += " return o;\n }\n};\n\n";
+ code += " return o;\n";
+ code += " }\n";
+ code += "};\n\n";
// Generate a convenient CreateX function that uses the above builder
// to create a table in one go.
@@ -1010,28 +1078,30 @@ class CppGenerator : public BaseGenerator {
code += "(flatbuffers::FlatBufferBuilder &_fbb";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
if (field.value.type.base_type == BASE_TYPE_STRING ||
field.value.type.base_type == BASE_TYPE_VECTOR) {
gen_vector_pars = true;
}
- GenSimpleParam(code, field);
+ GenSimpleParam(field, &code);
}
}
- code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n";
+ code += ") {\n";
+ code += " " + struct_def.name + "Builder builder_(_fbb);\n";
for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
size; size /= 2) {
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated && (!struct_def.sortbysize ||
size == SizeOf(field.value.type.base_type))) {
code += " builder_.add_" + field.name + "(" + field.name + ");\n";
}
}
}
- code += " return builder_.Finish();\n}\n\n";
+ code += " return builder_.Finish();\n";
+ code += "}\n\n";
// Generate a CreateXDirect function with vector types as parameters
if (gen_vector_pars) {
@@ -1040,27 +1110,27 @@ class CppGenerator : public BaseGenerator {
code += "Direct(flatbuffers::FlatBufferBuilder &_fbb";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
if (field.value.type.base_type == BASE_TYPE_STRING) {
- code += ",\n const char *";
+ code += ",\n";
+ code += " const char *";
code += field.name + " = nullptr";
} else if (field.value.type.base_type == BASE_TYPE_VECTOR) {
- code += ",\n const std::vector<";
+ code += ",\n";
+ code += " const std::vector<";
code += GenTypeWire(field.value.type.VectorType(), "", false);
code += "> *" + field.name + " = nullptr";
} else {
- GenSimpleParam(code, field);
+ GenSimpleParam(field, &code);
}
}
}
- code += ") {\n ";
- code += "return Create";
- code += struct_def.name;
- code += "(_fbb";
+ code += ") {\n";
+ code += " return Create" + struct_def.name + "(_fbb";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
if (field.value.type.base_type == BASE_TYPE_STRING) {
code += ", " + field.name + " ? ";
@@ -1075,7 +1145,8 @@ class CppGenerator : public BaseGenerator {
}
}
}
- code += ");\n}\n\n";
+ code += ");\n";
+ code += "}\n\n";
}
if (parser_.opts.generate_object_based_api) {
@@ -1088,31 +1159,32 @@ class CppGenerator : public BaseGenerator {
std::string GenUnpackVal(const Type &type, const std::string &val,
bool invector, const FieldDef &afield) {
switch (type.base_type) {
- case BASE_TYPE_STRING:
+ case BASE_TYPE_STRING: {
return val + "->str()";
- case BASE_TYPE_STRUCT:
+ }
+ case BASE_TYPE_STRUCT: {
+ const auto name = WrapInNameSpace(*type.struct_def);
if (IsStruct(type)) {
if (invector || afield.native_inline) {
return "*" + val;
} else {
- return GenTypeNativePtr(WrapInNameSpace(*type.struct_def),
- &afield, true) +
- "(new " +
- WrapInNameSpace(*type.struct_def) + "(*" + val + "))";
+ const auto ptype = GenTypeNativePtr(name, &afield, true);
+ return ptype + "(new " + name + "(*" + val + "))";
}
} else {
- return GenTypeNativePtr(NativeName(WrapInNameSpace(
- *type.struct_def)), &afield, true) +
- "(" + val + "->UnPack(resolver))";
+ const auto ptype = GenTypeNativePtr(NativeName(name), &afield, true);
+ return ptype + "(" + val + "->UnPack(resolver))";
}
- default:
+ }
+ default: {
return val;
break;
+ }
}
};
// Generate code for tables that needs to come after the regular definition.
- void GenTablePost(StructDef &struct_def, std::string *code_ptr) {
+ void GenTablePost(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
if (parser_.opts.generate_object_based_api) {
@@ -1122,7 +1194,7 @@ class CppGenerator : public BaseGenerator {
code += " auto _o = new " + NativeName(struct_def.name) + "();\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
if (!field.deprecated) {
auto prefix = " { auto _e = " + field.name + "(); ";
if (!IsScalar(field.value.type.base_type)) prefix += "if (_e) ";
@@ -1179,7 +1251,8 @@ class CppGenerator : public BaseGenerator {
code += " };\n";
}
}
- code += " return _o;\n}\n\n";
+ code += " return _o;\n";
+ code += "}\n\n";
// Generate the X::Pack member function that simply calls the global
// CreateX function.
@@ -1219,7 +1292,8 @@ class CppGenerator : public BaseGenerator {
stlprefix = "";
postfix = "";
}
- code += ",\n ";
+ code += ",\n";
+ code += " ";
switch (field.value.type.base_type) {
case BASE_TYPE_STRING:
code += stlprefix + "_fbb.CreateString(" + accessor + ")";
@@ -1285,41 +1359,40 @@ class CppGenerator : public BaseGenerator {
}
}
}
- code += ");\n}\n\n";
+ code += ");\n";
+ code += "}\n\n";
if (!any_fields) code.insert(before_return_statement, " (void)_o;\n");
}
}
- static void GenPadding(const FieldDef &field, std::string &code,
- int &padding_id,
- const std::function<void(int bits, std::string &code,
- int &padding_id)> &f) {
+ static void GenPadding(
+ const FieldDef &field, std::string *code_ptr, int *id,
+ const std::function<void(int bits, std::string *code_ptr, int *id)> &f) {
if (field.padding) {
for (int i = 0; i < 4; i++)
if (static_cast<int>(field.padding) & (1 << i))
- f((1 << i) * 8, code, padding_id);
+ f((1 << i) * 8, code_ptr, id);
assert(!(field.padding & ~0xF));
}
}
- static void PaddingDefinition(int bits, std::string &code, int &padding_id) {
- code += " int" + NumToString(bits) + "_t __padding" +
- NumToString(padding_id++) + ";\n";
+ static void PaddingDefinition(int bits, std::string *code_ptr, int *id) {
+ *code_ptr += " int" + NumToString(bits) + "_t __padding" +
+ NumToString((*id)++) + ";\n";
}
- static void PaddingDeclaration(int bits, std::string &code, int &padding_id) {
+ static void PaddingDeclaration(int bits, std::string *code_ptr, int *id) {
(void)bits;
- code += " (void)__padding" + NumToString(padding_id++) + ";";
+ *code_ptr += " (void)__padding" + NumToString((*id)++) + ";";
}
- static void PaddingInitializer(int bits, std::string &code, int &padding_id) {
+ static void PaddingInitializer(int bits, std::string *code_ptr, int *id) {
(void)bits;
- code += ", __padding" + NumToString(padding_id++) + "(0)";
+ *code_ptr += ", __padding" + NumToString((*id)++) + "(0)";
}
// Generate an accessor struct with constructor for a flatbuffers struct.
- void GenStruct(StructDef &struct_def, std::string *code_ptr) {
- if (struct_def.generated) return;
+ void GenStruct(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr;
// Generate an accessor struct, with private variables of the form:
@@ -1330,19 +1403,21 @@ class CppGenerator : public BaseGenerator {
GenComment(struct_def.doc_comment, code_ptr, nullptr);
code +=
"MANUALLY_ALIGNED_STRUCT(" + NumToString(struct_def.minalign) + ") ";
- code += struct_def.name + " FLATBUFFERS_FINAL_CLASS {\n private:\n";
+ code += struct_def.name + " FLATBUFFERS_FINAL_CLASS {\n";
+ code += " private:\n";
int padding_id = 0;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
code += " " + GenTypeGet(field.value.type, " ", "", " ", false);
code += field.name + "_;\n";
- GenPadding(field, code, padding_id, PaddingDefinition);
+ GenPadding(field, &code, &padding_id, PaddingDefinition);
}
// Generate GetFullyQualifiedName
- code += "\n public:\n";
- GenFullyQualifiedNameGetter(struct_def.name, code);
+ code += "\n";
+ code += " public:\n";
+ GenFullyQualifiedNameGetter(struct_def.name, &code);
// Generate a default constructor.
code += " " + struct_def.name + "() { memset(this, 0, sizeof(";
@@ -1354,46 +1429,46 @@ class CppGenerator : public BaseGenerator {
code += struct_def.name + ")); }\n";
// Generate a constructor that takes all fields as arguments.
- if (struct_def.fields.vec.size()) {
- code += " " + struct_def.name + "(";
- for (auto it = struct_def.fields.vec.begin();
- it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
- if (it != struct_def.fields.vec.begin()) code += ", ";
- code += GenTypeGet(field.value.type, " ", "const ", " &", true);
- code += "_" + field.name;
- }
- code += ")\n : ";
- padding_id = 0;
- for (auto it = struct_def.fields.vec.begin();
- it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
- if (it != struct_def.fields.vec.begin()) code += ", ";
- code += field.name + "_(";
- if (IsScalar(field.value.type.base_type)) {
- code += "flatbuffers::EndianScalar(";
- code += GenUnderlyingCast(field, false, "_" + field.name);
- code += "))";
- } else {
- code += "_" + field.name + ")";
- }
- GenPadding(field, code, padding_id, PaddingInitializer);
- }
- code += " {";
- padding_id = 0;
- for (auto it = struct_def.fields.vec.begin();
- it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
- GenPadding(field, code, padding_id, PaddingDeclaration);
+ code += " " + struct_def.name + "(";
+ for (auto it = struct_def.fields.vec.begin();
+ it != struct_def.fields.vec.end(); ++it) {
+ const auto &field = **it;
+ if (it != struct_def.fields.vec.begin()) code += ", ";
+ code += GenTypeGet(field.value.type, " ", "const ", " &", true);
+ code += "_" + field.name;
+ }
+ code += ")\n";
+ code += " : ";
+ padding_id = 0;
+ for (auto it = struct_def.fields.vec.begin();
+ it != struct_def.fields.vec.end(); ++it) {
+ const auto &field = **it;
+ if (it != struct_def.fields.vec.begin()) code += ", ";
+ code += field.name + "_(";
+ if (IsScalar(field.value.type.base_type)) {
+ code += "flatbuffers::EndianScalar(";
+ code += GenUnderlyingCast(field, false, "_" + field.name);
+ code += "))";
+ } else {
+ code += "_" + field.name + ")";
}
- code += " }\n\n";
+ GenPadding(field, &code, &padding_id, PaddingInitializer);
+ }
+
+ code += " {";
+ padding_id = 0;
+ for (auto it = struct_def.fields.vec.begin();
+ it != struct_def.fields.vec.end(); ++it) {
+ auto field = *it;
+ GenPadding(*field, &code, &padding_id, PaddingDeclaration);
}
+ code += " }\n\n";
// Generate accessor methods of the form:
// type name() const { return flatbuffers::EndianScalar(name_); }
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
- auto &field = **it;
+ const auto &field = **it;
GenComment(field.doc_comment, code_ptr, nullptr, " ");
auto is_scalar = IsScalar(field.value.type.base_type);
code += " " + GenTypeGet(field.value.type, " ", "const ", " &", true);
@@ -1419,15 +1494,16 @@ class CppGenerator : public BaseGenerator {
}
}
}
- code += "};\nSTRUCT_END(" + struct_def.name + ", ";
+ code += "};\n";
+ code += "STRUCT_END(" + struct_def.name + ", ";
code += NumToString(struct_def.bytesize) + ");\n\n";
}
- // Set up the correct namespace. Only open a namespace if
- // the existing one is different (closing/opening only what is necessary) :
+ // Set up the correct namespace. Only open a namespace if the existing one is
+ // different (closing/opening only what is necessary).
//
- // the file must start and end with an empty (or null) namespace
- // so that namespaces are properly opened and closed
+ // The file must start and end with an empty (or null) namespace so that
+ // namespaces are properly opened and closed.
void SetNameSpace(const Namespace *ns, std::string *code_ptr) {
if (cur_name_space_ == ns) return;
// compute the size of the longest common namespace prefix.
@@ -1467,10 +1543,10 @@ bool GenerateCPP(const Parser &parser, const std::string &path,
std::string CPPMakeRule(const Parser &parser, const std::string &path,
const std::string &file_name) {
- std::string filebase =
+ const std::string filebase =
flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
+ const auto included_files = parser.GetIncludedFilesRecursive(file_name);
std::string make_rule = GeneratedFileName(path, filebase) + ": ";
- auto included_files = parser.GetIncludedFilesRecursive(file_name);
for (auto it = included_files.begin(); it != included_files.end(); ++it) {
make_rule += " " + *it;
}
diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp
index 2d8d83cf..44d89b4c 100644
--- a/src/idl_gen_general.cpp
+++ b/src/idl_gen_general.cpp
@@ -276,7 +276,7 @@ class GeneralGenerator : public BaseGenerator {
return SaveFile(filename.c_str(), code, false);
}
- const Namespace *CurrentNameSpace() { return cur_name_space_; }
+ const Namespace *CurrentNameSpace() const { return cur_name_space_; }
std::string FunctionStart(char upper) {
return std::string() + (lang_.language == IDLOptions::kJava
diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h
index 0b73b7a2..bbe4487b 100644
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -78,7 +78,7 @@ template<> struct AnyTraits<MyGame::Example2::Monster> {
struct AnyUnion {
Any type;
- flatbuffers::NativeTable *table;
+ flatbuffers::NativeTable *table = nullptr;
AnyUnion() : type(Any_NONE), table(nullptr) {}
AnyUnion(const AnyUnion &);
AnyUnion &operator=(const AnyUnion &);
@@ -223,7 +223,9 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta
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); }
+ 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() {
@@ -279,9 +281,15 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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); }
+ 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() {
@@ -504,34 +512,90 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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_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);
+ }
MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
MonsterBuilder &operator=(const MonsterBuilder &);
flatbuffers::Offset<Monster> Finish() {
@@ -830,7 +894,9 @@ inline bool VerifyMonsterBuffer(flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
}
-inline const char *MonsterExtension() { return "mon"; }
+inline const char *MonsterExtension() {
+ return "mon";
+}
inline void FinishMonsterBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<MyGame::Example::Monster> root) {
fbb.Finish(root, MonsterIdentifier());
diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h
index 59d4030a..3e036694 100644
--- a/tests/namespace_test/namespace_test1_generated.h
+++ b/tests/namespace_test/namespace_test1_generated.h
@@ -61,7 +61,9 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInNestedNSBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_foo(int32_t foo) { fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0); }
+ void add_foo(int32_t foo) {
+ fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0);
+ }
TableInNestedNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
TableInNestedNSBuilder &operator=(const TableInNestedNSBuilder &);
flatbuffers::Offset<TableInNestedNS> Finish() {
diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h
index 77578bc6..693d9f83 100644
--- a/tests/namespace_test/namespace_test2_generated.h
+++ b/tests/namespace_test/namespace_test2_generated.h
@@ -48,9 +48,15 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInFirstNSBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) { fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table); }
- void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) { fbb_.AddElement<int8_t>(TableInFirstNS::VT_FOO_ENUM, static_cast<int8_t>(foo_enum), 0); }
- void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) { fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct); }
+ void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) {
+ fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table);
+ }
+ void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) {
+ fbb_.AddElement<int8_t>(TableInFirstNS::VT_FOO_ENUM, static_cast<int8_t>(foo_enum), 0);
+ }
+ void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) {
+ fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
+ }
TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
TableInFirstNSBuilder &operator=(const TableInFirstNSBuilder &);
flatbuffers::Offset<TableInFirstNS> Finish() {
@@ -96,8 +102,12 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableInCBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_refer_to_a1(flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) { fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1); }
- void add_refer_to_a2(flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) { fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2); }
+ void add_refer_to_a1(flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) {
+ fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1);
+ }
+ void add_refer_to_a2(flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) {
+ fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2);
+ }
TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
TableInCBuilder &operator=(const TableInCBuilder &);
flatbuffers::Offset<TableInC> Finish() {
@@ -136,7 +146,9 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct SecondTableInABuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_refer_to_c(flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) { fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c); }
+ void add_refer_to_c(flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) {
+ fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c);
+ }
SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
SecondTableInABuilder &operator=(const SecondTableInABuilder &);
flatbuffers::Offset<SecondTableInA> Finish() {
--
GitLab