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

@@ -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);
   }
 

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());

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() {

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;
   }

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

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());

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() {

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() {