Skip to content

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

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
parent b29ba4c7
Show whitespace changes
Inline Side-by-side
Showing with 612 additions and 364 deletions
include/flatbuffers/code_generators.h
View file @ cc842400
......@@ -23,7 +23,7 @@ class BaseGenerator {
public:
virtual bool generate() = 0;
static const std::string NamespaceDir(const Parser &parser,
static std::string NamespaceDir(const Parser &parser,
const std::string &path,
const Namespace &ns) {
EnsureDirExists(path.c_str());
......@@ -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);
}
......
include/flatbuffers/reflection_generated.h
View file @ cc842400
......@@ -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());
......
samples/monster_generated.h
View file @ cc842400
......@@ -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() {
......
src/idl_gen_cpp.cpp
View file @ cc842400
......@@ -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,44 +34,37 @@ 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 + "_";
}
guard += "H_";
std::transform(guard.begin(), guard.end(), guard.begin(), ::toupper);
return guard;
}
include_guard += "H_";
std::transform(include_guard.begin(), include_guard.end(),
include_guard.begin(), ::toupper);
code += "#ifndef " + include_guard + "\n";
code += "#define " + include_guard + "\n\n";
code += "#include \"flatbuffers/flatbuffers.h\"\n\n";
void GenIncludeDependencies(std::string* code_ptr) const {
std::string& code = *code_ptr;
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 =
const std::string basename =
flatbuffers::StripPath(flatbuffers::StripExtension(it->first));
if (basename != file_name_) {
code += "#include \"" + basename + "_generated.h\"\n";
......@@ -85,13 +74,31 @@ class CppGenerator : public BaseGenerator {
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) {
GenIncludeDependencies(&code);
}
assert(!cur_name_space_);
// Generate forward declarations for all structs/tables, since they may
// 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 + " *";
if (ptr_type != "naked") {
return ptr_type + "<" + type + ">";
} else if (is_constructor) {
return "";
} else {
return type + " *";
}
}
std::string GenPtrGet(const FieldDef &field) {
......@@ -325,54 +349,60 @@ 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);
}
}
}
// Return a C++ type for any type (scalar/pointer) specifically for
// using a flatbuffer.
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,20 +1429,20 @@ 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;
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 += ")\n";
code += " : ";
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;
if (it != struct_def.fields.vec.begin()) code += ", ";
code += field.name + "_(";
if (IsScalar(field.value.type.base_type)) {
......@@ -1377,23 +1452,23 @@ class CppGenerator : public BaseGenerator {
} else {
code += "_" + field.name + ")";
}
GenPadding(field, code, padding_id, PaddingInitializer);
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);
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;
}
......
src/idl_gen_general.cpp
View file @ cc842400
......@@ -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
......
tests/monster_test_generated.h
View file @ cc842400
......@@ -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());
......
tests/namespace_test/namespace_test1_generated.h
View file @ cc842400
......@@ -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() {
......
tests/namespace_test/namespace_test2_generated.h
View file @ cc842400
......@@ -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() {
......
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