Enforcing the google C++ style guide

include/flatbuffers/code_generators.h

@@ -17,48 +17,23 @@
 #ifndef FLATBUFFERS_CODE_GENERATORS_H_
 #define FLATBUFFERS_CODE_GENERATORS_H_
 
-/** This file defines some classes, that code generators should extend to gain
-   common functionalities :
-
-   BaseGenerator is the base class for all (binary, textual, strongly typed,
-   dynamically typed, whatever) generators.
-   It is really abstract, general and flexible and doesn't do much appart from
-   holding the parser, a path and a filename being processed.
-   Still, it brings a common structure (normalization) among generators
-
-   The many advantages of object based generators will come later from   :
-
-   A) the CodeWriter class (semi-automatic indentation (python), semi-automatic
-   (C++) namespace scopes, export to different files (classic, top level
-   methods),
-   simpler code to generate string from things (comments (vector of strings),
-   indentation commands (TAB BAT), newlines (NL), numbers, const char* or
-   std::string)
-
-   B) the Generator subclass (heritance for supporting different versions of a
-   language, avoid field name clash, write text/binary to file, types
-   management,
-   common computations and sctructures :  enum analysis (function, array, map,
-   ordered list + binarysearch),...)
-
-*/
 namespace flatbuffers {
 
 class BaseGenerator {
-public:
-  BaseGenerator(const Parser &parser_, const std::string &path_,
-                const std::string &file_name_)
-      : parser(parser_), path(path_), file_name(file_name_){};
+ public:
+  BaseGenerator(const Parser &parser, const std::string &path,
+                const std::string &file_name)
+      : parser_(parser), path_(path), file_name_(file_name){};
   virtual bool generate() = 0;
 
-protected:
+ protected:
   virtual ~BaseGenerator(){};
 
-  const Parser &parser;
-  const std::string &path;
-  const std::string &file_name;
+  const Parser &parser_;
+  const std::string &path_;
+  const std::string &file_name_;
 };
 
-} // namespace flatbuffers
+}  // namespace flatbuffers
 
-#endif // FLATBUFFERS_CODE_GENERATORS_H_
+#endif  // FLATBUFFERS_CODE_GENERATORS_H_

src/idl_gen_general.cpp

@@ -1147,58 +1147,54 @@ static bool SaveClass(const LanguageParameters &lang, const Parser &parser,
   return SaveFile(filename.c_str(), code, false);
 }
 
-/** it'll be split later in java/csharp... and moved to separate files */
 namespace general {
-/** members methods signature will be simpler as they won't have to pass parser,
- * filename & path */
-/** more features coming through the JavaGenerator, CSharpGenerator ...*/
 class GeneralGenerator : public BaseGenerator {
-public:
-  GeneralGenerator(const Parser &parser_, const std::string &path_,
-                   const std::string &file_name_)
-      : BaseGenerator(parser_, path_, file_name_){};
+ public:
+  GeneralGenerator(const Parser &parser, const std::string &path,
+                   const std::string &file_name)
+      : BaseGenerator(parser, path, file_name){};
   bool generate() {
- assert(parser.opts.lang <= IDLOptions::kMAX);
-  auto lang = language_parameters[parser.opts.lang];
-  std::string one_file_code;
+    assert(parser_.opts.lang <= IDLOptions::kMAX);
+    auto lang = language_parameters[parser_.opts.lang];
+    std::string one_file_code;
 
-  for (auto it = parser.enums_.vec.begin();
-       it != parser.enums_.vec.end(); ++it) {
-    std::string enumcode;
-    GenEnum(lang, parser, **it, &enumcode);
-    if (parser.opts.one_file) {
-      one_file_code += enumcode;
-    }
-    else {
-      if (!SaveClass(lang, parser, (**it).name, enumcode, path, false, false))
-        return false;
+    for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
+         ++it) {
+      std::string enumcode;
+      GenEnum(lang, parser_, **it, &enumcode);
+      if (parser_.opts.one_file) {
+        one_file_code += enumcode;
+      } else {
+        if (!SaveClass(lang, parser_, (**it).name, enumcode, path_, false,
+                       false))
+          return false;
+      }
     }
-  }
 
-  for (auto it = parser.structs_.vec.begin();
-       it != parser.structs_.vec.end(); ++it) {
-    std::string declcode;
-    GenStruct(lang, parser, **it, &declcode);
-    if (parser.opts.one_file) {
-      one_file_code += declcode;
-    }
-    else {
-      if (!SaveClass(lang, parser, (**it).name, declcode, path, true, false))
-        return false;
+    for (auto it = parser_.structs_.vec.begin();
+         it != parser_.structs_.vec.end(); ++it) {
+      std::string declcode;
+      GenStruct(lang, parser_, **it, &declcode);
+      if (parser_.opts.one_file) {
+        one_file_code += declcode;
+      } else {
+        if (!SaveClass(lang, parser_, (**it).name, declcode, path_, true,
+                       false))
+          return false;
+      }
     }
-  }
 
-  if (parser.opts.one_file) {
-    return SaveClass(lang, parser, file_name, one_file_code,path, true, true);
-  }
-  return true;
+    if (parser_.opts.one_file) {
+      return SaveClass(lang, parser_, file_name_, one_file_code, path_, true,
+                       true);
+    }
+    return true;
   }
 };
-} // namespace general
+}  // namespace general
 
-bool GenerateGeneral(const Parser &parser,
-                     const std::string &path,
-                     const std::string & file_name) {
+bool GenerateGeneral(const Parser &parser, const std::string &path,
+                     const std::string &file_name) {
   general::GeneralGenerator *generator =
       new general::GeneralGenerator(parser, path, file_name);
   return generator->generate();

src/idl_gen_go.cpp

@@ -662,35 +662,32 @@ static void GenStructBuilder(const StructDef &struct_def,
 }
 
 class GoGenerator : public BaseGenerator {
-public:
-  GoGenerator(const Parser &parser_, const std::string &path_,
-              const std::string &file_name_)
-      : BaseGenerator(parser_, path_, file_name_){};
+ public:
+  GoGenerator(const Parser &parser, const std::string &path,
+              const std::string &file_name)
+      : BaseGenerator(parser, path, file_name){};
   bool generate() {
-  for (auto it = parser.enums_.vec.begin();
-       it != parser.enums_.vec.end(); ++it) {
-    std::string enumcode;
-    go::GenEnum(**it, &enumcode);
-    if (!go::SaveType(parser, **it, enumcode, path, false))
-      return false;
-  }
+    for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
+         ++it) {
+      std::string enumcode;
+      go::GenEnum(**it, &enumcode);
+      if (!go::SaveType(parser_, **it, enumcode, path_, false)) return false;
+    }
 
-  for (auto it = parser.structs_.vec.begin();
-       it != parser.structs_.vec.end(); ++it) {
-    std::string declcode;
-    go::GenStruct(**it, &declcode, parser.root_struct_def_);
-    if (!go::SaveType(parser, **it, declcode, path, true))
-      return false;
-  }
+    for (auto it = parser_.structs_.vec.begin();
+         it != parser_.structs_.vec.end(); ++it) {
+      std::string declcode;
+      go::GenStruct(**it, &declcode, parser_.root_struct_def_);
+      if (!go::SaveType(parser_, **it, declcode, path_, true)) return false;
+    }
 
-  return true;
+    return true;
   }
 };
 }  // namespace go
 
-bool GenerateGo(const Parser &parser,
-                const std::string &path,
-                const std::string & file_name) {
+bool GenerateGo(const Parser &parser, const std::string &path,
+                const std::string &file_name) {
   go::GoGenerator *generator = new go::GoGenerator(parser, path, file_name);
   return generator->generate();
 }