Made all C++ files clang-formatted.

Also added missing generated files.

Change-Id: Ifd22a643a08e3f2edfce92812ed57b87fc0e1875

.clang-format

@@ -3,5 +3,11 @@ Language:        Cpp
 BasedOnStyle: Google
 DerivePointerAlignment: false
 PointerAlignment: Right
+IndentPPDirectives: AfterHash
+Cpp11BracedListStyle: false
+AlwaysBreakTemplateDeclarations: false
+AllowShortCaseLabelsOnASingleLine: true
+SpaceAfterTemplateKeyword: false
+AllowShortBlocksOnASingleLine: true
 ...
 

grpc/src/compiler/schema_interface.h

@@ -40,8 +40,8 @@
 #include <vector>
 
 #ifndef GRPC_CUSTOM_STRING
-#include <string>
-#define GRPC_CUSTOM_STRING std::string
+#  include <string>
+#  define GRPC_CUSTOM_STRING std::string
 #endif
 
 namespace grpc {

grpc/tests/grpctest.cpp

@@ -18,41 +18,43 @@
 
 #include <grpc++/grpc++.h>
 
-#include "monster_test_generated.h"
 #include "monster_test.grpc.fb.h"
+#include "monster_test_generated.h"
 
 using namespace MyGame::Example;
 
 // The callback implementation of our server, that derives from the generated
 // code. It implements all rpcs specified in the FlatBuffers schema.
 class ServiceImpl final : public MyGame::Example::MonsterStorage::Service {
-  virtual ::grpc::Status Store(::grpc::ServerContext* context,
+  virtual ::grpc::Status Store(
+      ::grpc::ServerContext *context,
       const flatbuffers::grpc::Message<Monster> *request,
-                               flatbuffers::grpc::Message<Stat> *response)
-                               override {
+      flatbuffers::grpc::Message<Stat> *response) override {
     // Create a response from the incoming request name.
     fbb_.Clear();
-    auto stat_offset = CreateStat(fbb_, fbb_.CreateString("Hello, " +
-                                        request->GetRoot()->name()->str()));
+    auto stat_offset = CreateStat(
+        fbb_, fbb_.CreateString("Hello, " + request->GetRoot()->name()->str()));
     fbb_.Finish(stat_offset);
     // Transfer ownership of the message to gRPC
     *response = fbb_.ReleaseMessage<Stat>();
     return grpc::Status::OK;
   }
-  virtual ::grpc::Status Retrieve(::grpc::ServerContext *context,
+  virtual ::grpc::Status Retrieve(
+      ::grpc::ServerContext *context,
       const flatbuffers::grpc::Message<Stat> *request,
-                               ::grpc::ServerWriter< flatbuffers::grpc::Message<Monster>>* writer)
+      ::grpc::ServerWriter<flatbuffers::grpc::Message<Monster>> *writer)
       override {
-
-    for (int i=0; i<10; i++) {
+    for (int i = 0; i < 10; i++) {
       fbb_.Clear();
       // Create 10 monsters for resposne.
       auto monster_offset =
-       CreateMonster(fbb_, 0, 0, 0, fbb_.CreateString(
-         request->GetRoot()->id()->str() + " No." + std::to_string(i)));
+          CreateMonster(fbb_, 0, 0, 0,
+                        fbb_.CreateString(request->GetRoot()->id()->str() +
+                                          " No." + std::to_string(i)));
       fbb_.Finish(monster_offset);
 
-       flatbuffers::grpc::Message<Monster> monster = fbb_.ReleaseMessage<Monster>();
+      flatbuffers::grpc::Message<Monster> monster =
+          fbb_.ReleaseMessage<Monster>();
 
       // Send monster to client using streaming.
       writer->Write(monster);
@@ -90,7 +92,7 @@ void RunServer() {
   server_instance->Wait();
 }
 
-int main(int /*argc*/, const char * /*argv*/[]) {
+int main(int /*argc*/, const char * /*argv*/ []) {
   // Launch server.
   std::thread server_thread(RunServer);
 
@@ -103,7 +105,6 @@ int main(int /*argc*/, const char * /*argv*/[]) {
                                      grpc::InsecureChannelCredentials());
   auto stub = MyGame::Example::MonsterStorage::NewStub(channel);
 
-
   flatbuffers::grpc::MessageBuilder fbb;
   {
     grpc::ClientContext context;
@@ -138,7 +139,7 @@ int main(int /*argc*/, const char * /*argv*/[]) {
     }
   }
 
-  #if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
+#if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
   {
     // Test that an invalid request errors out correctly
     grpc::ClientContext context;
@@ -149,9 +150,10 @@ int main(int /*argc*/, const char * /*argv*/[]) {
     // matches the protobuf gRPC status code for an unparseable message.
     assert(!status.ok());
     assert(status.error_code() == ::grpc::StatusCode::INTERNAL);
-    assert(strcmp(status.error_message().c_str(), "Message verification failed") == 0);
+    assert(strcmp(status.error_message().c_str(),
+                  "Message verification failed") == 0);
   }
-  #endif
+#endif
 
   server_instance->Shutdown();
 

include/flatbuffers/base.h

 #ifndef FLATBUFFERS_BASE_H_
 #define FLATBUFFERS_BASE_H_
 
+// clang-format off
 #if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \
     defined(_MSC_VER) && defined(_DEBUG)
   #define _CRTDBG_MAP_ALLOC

include/flatbuffers/code_generators.h

@@ -49,7 +49,7 @@ class CodeWriter {
   // Associates a key with a value.  All subsequent calls to operator+=, where
   // the specified key is contained in {{ and }} delimiters will be replaced by
   // the given value.
-  void SetValue(const std::string& key, const std::string& value) {
+  void SetValue(const std::string &key, const std::string &value) {
     value_map_[key] = value;
   }
 
@@ -71,8 +71,7 @@ class BaseGenerator {
  public:
   virtual bool generate() = 0;
 
-  static std::string NamespaceDir(const Parser &parser,
-                                  const std::string &path,
+  static std::string NamespaceDir(const Parser &parser, const std::string &path,
                                   const Namespace &ns);
 
  protected:
@@ -128,8 +127,7 @@ struct CommentConfig {
 };
 
 extern void GenComment(const std::vector<std::string> &dc,
-                       std::string *code_ptr,
-                       const CommentConfig *config,
+                       std::string *code_ptr, const CommentConfig *config,
                        const char *prefix = "");
 
 }  // namespace flatbuffers

include/flatbuffers/flatc.h

@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/idl.h"
-#include "flatbuffers/util.h"
 #include <functional>
 #include <limits>
 #include <string>
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
 
 #ifndef FLATC_H_
-#define FLATC_H_
+#  define FLATC_H_
 
 namespace flatbuffers {
 
@@ -49,12 +49,10 @@ class FlatCompiler {
     MakeRuleFn make_rule;
   };
 
-  typedef void (*WarnFn)(const FlatCompiler *flatc,
-                         const std::string &warn,
+  typedef void (*WarnFn)(const FlatCompiler *flatc, const std::string &warn,
                          bool show_exe_name);
 
-  typedef void (*ErrorFn)(const FlatCompiler *flatc,
-                          const std::string &err,
+  typedef void (*ErrorFn)(const FlatCompiler *flatc, const std::string &err,
                           bool usage, bool show_exe_name);
 
   // Parameters required to initialize the FlatCompiler.
@@ -65,21 +63,20 @@ class FlatCompiler {
           warn_fn(nullptr),
           error_fn(nullptr) {}
 
-    const Generator* generators;
+    const Generator *generators;
     size_t num_generators;
     WarnFn warn_fn;
     ErrorFn error_fn;
   };
 
-  explicit FlatCompiler(const InitParams& params) : params_(params) {}
+  explicit FlatCompiler(const InitParams &params) : params_(params) {}
 
-  int Compile(int argc, const char** argv);
+  int Compile(int argc, const char **argv);
 
-  std::string GetUsageString(const char* program_name) const;
+  std::string GetUsageString(const char *program_name) const;
 
  private:
-  void ParseFile(flatbuffers::Parser &parser,
-                 const std::string &filename,
+  void ParseFile(flatbuffers::Parser &parser, const std::string &filename,
                  const std::string &contents,
                  std::vector<const char *> &include_directories) const;
 
@@ -91,7 +88,6 @@ class FlatCompiler {
   InitParams params_;
 };
 
-
 }  // namespace flatbuffers
 
 #endif  // FLATC_H_

include/flatbuffers/grpc.h

@@ -30,8 +30,7 @@ namespace grpc {
 // `grpc_slice` and also provides flatbuffers-specific helpers such as `Verify`
 // and `GetRoot`. Since it is backed by a `grpc_slice`, the underlying buffer
 // is refcounted and ownership is be managed automatically.
-template <class T>
-class Message {
+template<class T> class Message {
  public:
   Message() : slice_(grpc_empty_slice()) {}
 
@@ -137,7 +136,7 @@ namespace detail {
 struct SliceAllocatorMember {
   SliceAllocator slice_allocator_;
 };
-}
+}  // namespace detail
 
 // MessageBuilder is a gRPC-specific FlatBufferBuilder that uses SliceAllocator
 // to allocate gRPC buffers.
@@ -155,8 +154,7 @@ class MessageBuilder : private detail::SliceAllocatorMember,
   // GetMessage extracts the subslice of the buffer corresponding to the
   // flatbuffers-encoded region and wraps it in a `Message<T>` to handle buffer
   // ownership.
-  template <class T>
-  Message<T> GetMessage() {
+  template<class T> Message<T> GetMessage() {
     auto buf_data = buf_.buf();       // pointer to memory
     auto buf_size = buf_.capacity();  // size of memory
     auto msg_data = buf_.data();      // pointer to msg
@@ -178,8 +176,7 @@ class MessageBuilder : private detail::SliceAllocatorMember,
     return msg;
   }
 
-  template <class T>
-  Message<T> ReleaseMessage() {
+  template<class T> Message<T> ReleaseMessage() {
     Message<T> msg = GetMessage<T>();
     Reset();
     return msg;
@@ -194,8 +191,7 @@ class MessageBuilder : private detail::SliceAllocatorMember,
 
 namespace grpc {
 
-template <class T>
-class SerializationTraits<flatbuffers::grpc::Message<T>> {
+template<class T> class SerializationTraits<flatbuffers::grpc::Message<T>> {
  public:
   static grpc::Status Serialize(const flatbuffers::grpc::Message<T> &msg,
                                 grpc_byte_buffer **buffer, bool *own_buffer) {
@@ -237,19 +233,19 @@ class SerializationTraits<flatbuffers::grpc::Message<T>> {
       *msg = flatbuffers::grpc::Message<T>(slice, false);
     }
     grpc_byte_buffer_destroy(buffer);
-    #if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
+#if FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION
     return ::grpc::Status::OK;
-    #else
+#else
     if (msg->Verify()) {
       return ::grpc::Status::OK;
     } else {
       return ::grpc::Status(::grpc::StatusCode::INTERNAL,
                             "Message verification failed");
     }
-    #endif
+#endif
   }
 };
 
-}  // namespace grpc;
+}  // namespace grpc
 
 #endif  // FLATBUFFERS_GRPC_H_

include/flatbuffers/hash.h

@@ -24,26 +24,22 @@
 
 namespace flatbuffers {
 
-template <typename T>
-struct FnvTraits {
+template<typename T> struct FnvTraits {
   static const T kFnvPrime;
   static const T kOffsetBasis;
 };
 
-template <>
-struct FnvTraits<uint32_t> {
+template<> struct FnvTraits<uint32_t> {
   static const uint32_t kFnvPrime = 0x01000193;
   static const uint32_t kOffsetBasis = 0x811C9DC5;
 };
 
-template <>
-struct FnvTraits<uint64_t> {
+template<> struct FnvTraits<uint64_t> {
   static const uint64_t kFnvPrime = 0x00000100000001b3ULL;
   static const uint64_t kOffsetBasis = 0xcbf29ce484222645ULL;
 };
 
-template <typename T>
-T HashFnv1(const char *input) {
+template<typename T> T HashFnv1(const char *input) {
   T hash = FnvTraits<T>::kOffsetBasis;
   for (const char *c = input; *c; ++c) {
     hash *= FnvTraits<T>::kFnvPrime;
@@ -52,8 +48,7 @@ T HashFnv1(const char *input) {
   return hash;
 }
 
-template <typename T>
-T HashFnv1a(const char *input) {
+template<typename T> T HashFnv1a(const char *input) {
   T hash = FnvTraits<T>::kOffsetBasis;
   for (const char *c = input; *c; ++c) {
     hash ^= static_cast<unsigned char>(*c);
@@ -62,11 +57,10 @@ T HashFnv1a(const char *input) {
   return hash;
 }
 
-template <typename T>
-struct NamedHashFunction {
+template<typename T> struct NamedHashFunction {
   const char *name;
 
-  typedef T (*HashFunction)(const char*);
+  typedef T (*HashFunction)(const char *);
   HashFunction function;
 };
 

include/flatbuffers/idl.h

@@ -18,17 +18,17 @@
 #define FLATBUFFERS_IDL_H_
 
 #include <map>
-#include <stack>
 #include <memory>
+#include <stack>
 
 #include "flatbuffers/base.h"
 #include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
 #include "flatbuffers/hash.h"
 #include "flatbuffers/reflection.h"
-#include "flatbuffers/flexbuffers.h"
 
 #if !defined(FLATBUFFERS_CPP98_STL)
-  #include <functional>
+#  include <functional>
 #endif  // !defined(FLATBUFFERS_CPP98_STL)
 
 // This file defines the data types representing a parsed IDL (Interface
@@ -39,6 +39,7 @@ namespace flatbuffers {
 // The order of these matters for Is*() functions below.
 // Additionally, Parser::ParseType assumes bool..string is a contiguous range
 // of type tokens.
+// clang-format off
 #define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
   TD(NONE,   "",       uint8_t,  byte,   byte,    byte,   uint8) \
   TD(UTYPE,  "",       uint8_t,  byte,   byte,    byte,   uint8) /* begin scalar/int */ \
@@ -110,13 +111,12 @@ inline bool IsFloat  (BaseType t) { return t == BASE_TYPE_FLOAT ||
 inline bool IsLong   (BaseType t) { return t == BASE_TYPE_LONG ||
                                            t == BASE_TYPE_ULONG; }
 inline bool IsBool   (BaseType t) { return t == BASE_TYPE_BOOL; }
+// clang-format on
 
 extern const char *const kTypeNames[];
 extern const char kTypeSizes[];
 
-inline size_t SizeOf(BaseType t) {
-  return kTypeSizes[t];
-}
+inline size_t SizeOf(BaseType t) { return kTypeSizes[t]; }
 
 struct StructDef;
 struct EnumDef;
@@ -125,13 +125,12 @@ class Parser;
 // Represents any type in the IDL, which is a combination of the BaseType
 // and additional information for vectors/structs_.
 struct Type {
-  explicit Type(BaseType _base_type = BASE_TYPE_NONE,
-                StructDef *_sd = nullptr, EnumDef *_ed = nullptr)
+  explicit Type(BaseType _base_type = BASE_TYPE_NONE, StructDef *_sd = nullptr,
+                EnumDef *_ed = nullptr)
       : base_type(_base_type),
         element(BASE_TYPE_NONE),
         struct_def(_sd),
-      enum_def(_ed)
-  {}
+        enum_def(_ed) {}
 
   bool operator==(const Type &o) {
     return base_type == o.base_type && element == o.element &&
@@ -151,8 +150,9 @@ struct Type {
 
 // Represents a parsed scalar value, it's type, and field offset.
 struct Value {
-  Value() : constant("0"), offset(static_cast<voffset_t>(
-                                ~(static_cast<voffset_t>(0U)))) {}
+  Value()
+      : constant("0"),
+        offset(static_cast<voffset_t>(~(static_cast<voffset_t>(0U)))) {}
   Type type;
   std::string constant;
   voffset_t offset;
@@ -163,9 +163,7 @@ struct Value {
 template<typename T> class SymbolTable {
  public:
   ~SymbolTable() {
-    for (auto it = vec.begin(); it != vec.end(); ++it) {
-      delete *it;
-    }
+    for (auto it = vec.begin(); it != vec.end(); ++it) { delete *it; }
   }
 
   bool Add(const std::string &name, T *e) {
@@ -201,7 +199,6 @@ template<typename T> class SymbolTable {
 struct Namespace {
   Namespace() : from_table(0) {}
 
-
   // Given a (potentally unqualified) name, return the "fully qualified" name
   // which has a full namespaced descriptor.
   // With max_components you can request less than the number of components
@@ -215,13 +212,16 @@ struct Namespace {
 
 // Base class for all definition types (fields, structs_, enums_).
 struct Definition {
-  Definition() : generated(false), defined_namespace(nullptr),
-                 serialized_location(0), index(-1), refcount(1) {}
+  Definition()
+      : generated(false),
+        defined_namespace(nullptr),
+        serialized_location(0),
+        index(-1),
+        refcount(1) {}
 
-  flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<
-    reflection::KeyValue>>>
-      SerializeAttributes(FlatBufferBuilder *builder,
-                          const Parser &parser) const;
+  flatbuffers::Offset<
+      flatbuffers::Vector<flatbuffers::Offset<reflection::KeyValue>>>
+  SerializeAttributes(FlatBufferBuilder *builder, const Parser &parser) const;
 
   std::string name;
   std::string file;
@@ -237,8 +237,13 @@ struct Definition {
 };
 
 struct FieldDef : public Definition {
-  FieldDef() : deprecated(false), required(false), key(false),
-               native_inline(false), flexbuffer(false), nested_flatbuffer(NULL),
+  FieldDef()
+      : deprecated(false),
+        required(false),
+        key(false),
+        native_inline(false),
+        flexbuffer(false),
+        nested_flatbuffer(NULL),
         padding(0) {}
 
   Offset<reflection::Field> Serialize(FlatBufferBuilder *builder, uint16_t id,
@@ -263,8 +268,7 @@ struct StructDef : public Definition {
         sortbysize(true),
         has_key(false),
         minalign(1),
-      bytesize(0)
-    {}
+        bytesize(0) {}
 
   void PadLastField(size_t min_align) {
     auto padding = PaddingBytes(bytesize, min_align);
@@ -300,8 +304,7 @@ inline size_t InlineAlignment(const Type &type) {
 }
 
 struct EnumVal {
-  EnumVal(const std::string &_name, int64_t _val)
-    : name(_name), value(_val) {}
+  EnumVal(const std::string &_name, int64_t _val) : name(_name), value(_val) {}
 
   Offset<reflection::EnumVal> Serialize(FlatBufferBuilder *builder) const;
 
@@ -315,12 +318,10 @@ struct EnumDef : public Definition {
   EnumDef() : is_union(false), uses_type_aliases(false) {}
 
   EnumVal *ReverseLookup(int enum_idx, bool skip_union_default = true) {
-    for (auto it = vals.vec.begin() + static_cast<int>(is_union &&
-                                                       skip_union_default);
+    for (auto it = vals.vec.begin() +
+                   static_cast<int>(is_union && skip_union_default);
          it != vals.vec.end(); ++it) {
-      if ((*it)->value == enum_idx) {
-        return *it;
-      }
+      if ((*it)->value == enum_idx) { return *it; }
     }
     return nullptr;
   }
@@ -338,8 +339,7 @@ inline bool EqualByName(const Type &a, const Type &b) {
   return a.base_type == b.base_type && a.element == b.element &&
          (a.struct_def == b.struct_def ||
           a.struct_def->name == b.struct_def->name) &&
-         (a.enum_def == b.enum_def ||
-          a.enum_def->name == b.enum_def->name);
+         (a.enum_def == b.enum_def || a.enum_def->name == b.enum_def->name);
 }
 
 struct RPCCall {
@@ -419,7 +419,9 @@ struct IDLOptions {
         use_goog_js_export_format(false),
         output_default_scalars_in_json(false),
         indent_step(2),
-      output_enum_identifiers(true), prefixed_enums(true), scoped_enums(false),
+        output_enum_identifiers(true),
+        prefixed_enums(true),
+        scoped_enums(false),
         include_dependence_headers(true),
         mutable_buffer(false),
         one_file(false),
@@ -481,7 +483,10 @@ class CheckedError {
 
   ~CheckedError() { assert(has_been_checked_); }
 
-  bool Check() { has_been_checked_ = true; return is_error_; }
+  bool Check() {
+    has_been_checked_ = true;
+    return is_error_;
+  }
 
  private:
   bool is_error_;
@@ -490,12 +495,14 @@ class CheckedError {
 
 // Additionally, in GCC we can get these errors statically, for additional
 // assurance:
+// clang-format off
 #ifdef __GNUC__
 #define FLATBUFFERS_CHECKED_ERROR CheckedError \
           __attribute__((warn_unused_result))
 #else
 #define FLATBUFFERS_CHECKED_ERROR CheckedError
 #endif
+// clang-format on
 
 class Parser : public ParserState {
  public:
@@ -581,7 +588,7 @@ class Parser : public ParserState {
 
   StructDef *LookupStruct(const std::string &id) const;
 
-private:
+ private:
   void Message(const std::string &msg);
   void Warning(const std::string &msg);
   FLATBUFFERS_CHECKED_ERROR Error(const std::string &msg);
@@ -606,6 +613,7 @@ private:
   FLATBUFFERS_CHECKED_ERROR ParseAnyValue(Value &val, FieldDef *field,
                                           size_t parent_fieldn,
                                           const StructDef *parent_struct_def);
+  // clang-format off
   #if defined(FLATBUFFERS_CPP98_STL)
     typedef CheckedError (*ParseTableDelimitersBody)(
         const std::string &name, size_t &fieldn, const StructDef *struct_def,
@@ -615,6 +623,7 @@ private:
                                        const StructDef*, void*)>
             ParseTableDelimitersBody;
   #endif  // defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on
   FLATBUFFERS_CHECKED_ERROR ParseTableDelimiters(size_t &fieldn,
                                                  const StructDef *struct_def,
                                                  ParseTableDelimitersBody body,
@@ -623,6 +632,7 @@ private:
                                        std::string *value, uoffset_t *ovalue);
   void SerializeStruct(const StructDef &struct_def, const Value &val);
   void AddVector(bool sortbysize, int count);
+  // clang-format off
   #if defined(FLATBUFFERS_CPP98_STL)
     typedef CheckedError (*ParseVectorDelimitersBody)(size_t &count,
                                                       void *state);
@@ -630,6 +640,7 @@ private:
     typedef std::function<CheckedError(size_t&, void*)>
             ParseVectorDelimitersBody;
   #endif  // defined(FLATBUFFERS_CPP98_STL)
+  // clang-format on
   FLATBUFFERS_CHECKED_ERROR ParseVectorDelimiters(
       size_t &count, ParseVectorDelimitersBody body, void *state);
   FLATBUFFERS_CHECKED_ERROR ParseVector(const Type &type, uoffset_t *ovalue);

include/flatbuffers/minireflect.h

@@ -65,8 +65,7 @@ struct IterationVisitor {
   virtual void EndVector() {}
   virtual void Element(size_t /*i*/, ElementaryType /*type*/,
                        const TypeTable * /*type_table*/,
-                       const uint8_t * /*val*/)
-  {}
+                       const uint8_t * /*val*/) {}
   virtual ~IterationVisitor() {}
 };
 
@@ -75,34 +74,24 @@ inline size_t InlineSize(ElementaryType type, const TypeTable *type_table) {
     case ET_UTYPE:
     case ET_BOOL:
     case ET_CHAR:
-    case ET_UCHAR:
-      return 1;
+    case ET_UCHAR: return 1;
     case ET_SHORT:
-    case ET_USHORT:
-      return 2;
+    case ET_USHORT: return 2;
     case ET_INT:
     case ET_UINT:
     case ET_FLOAT:
-    case ET_STRING:
-      return 4;
+    case ET_STRING: return 4;
     case ET_LONG:
     case ET_ULONG:
-    case ET_DOUBLE:
-      return 8;
+    case ET_DOUBLE: return 8;
     case ET_SEQUENCE:
       switch (type_table->st) {
         case ST_TABLE:
-        case ST_UNION:
-          return 4;
-        case ST_STRUCT:
-          return type_table->values[type_table->num_elems];
-        default:
-          assert(false);
-          return 1;
-      }
-    default:
-      assert(false);
-      return 1;
+        case ST_UNION: return 4;
+        case ST_STRUCT: return type_table->values[type_table->num_elems];
+        default: assert(false); return 1;
+      }
+    default: assert(false); return 1;
   }
 }
 
@@ -129,10 +118,8 @@ void IterateObject(const uint8_t *obj, const TypeTable *type_table,
                    IterationVisitor *visitor);
 
 inline void IterateValue(ElementaryType type, const uint8_t *val,
-                         const TypeTable *type_table,
-                         const uint8_t *prev_val,
-                         soffset_t vector_index,
-                         IterationVisitor *visitor) {
+                         const TypeTable *type_table, const uint8_t *prev_val,
+                         soffset_t vector_index, IterationVisitor *visitor) {
   switch (type) {
     case ET_UTYPE: {
       auto tval = *reinterpret_cast<const uint8_t *>(val);
@@ -200,9 +187,7 @@ inline void IterateValue(ElementaryType type, const uint8_t *val,
           val += ReadScalar<uoffset_t>(val);
           IterateObject(val, type_table, visitor);
           break;
-        case ST_STRUCT:
-          IterateObject(val, type_table, visitor);
-          break;
+        case ST_STRUCT: IterateObject(val, type_table, visitor); break;
         case ST_UNION: {
           val += ReadScalar<uoffset_t>(val);
           assert(prev_val);
@@ -211,10 +196,10 @@ inline void IterateValue(ElementaryType type, const uint8_t *val,
             auto type_vec = reinterpret_cast<const Vector<uint8_t> *>(prev_val);
             union_type = type_vec->Get(static_cast<uoffset_t>(vector_index));
           }
-          auto type_code_idx = LookupEnum(union_type, type_table->values,
-                                          type_table->num_elems);
-          if (type_code_idx >= 0 && type_code_idx <
-              static_cast<int32_t>(type_table->num_elems)) {
+          auto type_code_idx =
+              LookupEnum(union_type, type_table->values, type_table->num_elems);
+          if (type_code_idx >= 0 &&
+              type_code_idx < static_cast<int32_t>(type_table->num_elems)) {
             auto type_code = type_table->type_codes[type_code_idx];
             switch (type_code.base_type) {
               case ET_SEQUENCE: {
@@ -225,17 +210,14 @@ inline void IterateValue(ElementaryType type, const uint8_t *val,
               case ET_STRING:
                 visitor->String(reinterpret_cast<const String *>(val));
                 break;
-              default:
-                visitor->Unknown(val);
+              default: visitor->Unknown(val);
             }
           } else {
             visitor->Unknown(val);
           }
           break;
         }
-        case ST_ENUM:
-          assert(false);
-          break;
+        case ST_ENUM: assert(false); break;
       }
       break;
     }
@@ -257,9 +239,7 @@ inline void IterateObject(const uint8_t *obj, const TypeTable *type_table,
     auto is_vector = type_code.is_vector != 0;
     auto ref_idx = type_code.sequence_ref;
     const TypeTable *ref = nullptr;
-    if (ref_idx >= 0) {
-      ref = type_table->type_refs[ref_idx]();
-    }
+    if (ref_idx >= 0) { ref = type_table->type_refs[ref_idx](); }
     auto name = type_table->names ? type_table->names[i] : nullptr;
     const uint8_t *val = nullptr;
     if (type_table->st == ST_TABLE) {
@@ -310,24 +290,29 @@ struct ToStringVisitor : public IterationVisitor {
              const char *name, const uint8_t *val) {
     if (!val) return;
     if (set_idx) s += ", ";
-    if (name) { s += name; s += ": "; }
+    if (name) {
+      s += name;
+      s += ": ";
+    }
   }
   template<typename T> void Named(T x, const char *name) {
-    if (name) s+= name;
-    else s+= NumToString(x);
+    if (name)
+      s += name;
+    else
+      s += NumToString(x);
   }
   void UType(uint8_t x, const char *name) { Named(x, name); }
-  void Bool(bool x) { s+= x ? "true" : "false"; }
+  void Bool(bool x) { s += x ? "true" : "false"; }
   void Char(int8_t x, const char *name) { Named(x, name); }
   void UChar(uint8_t x, const char *name) { Named(x, name); }
   void Short(int16_t x, const char *name) { Named(x, name); }
   void UShort(uint16_t x, const char *name) { Named(x, name); }
   void Int(int32_t x, const char *name) { Named(x, name); }
   void UInt(uint32_t x, const char *name) { Named(x, name); }
-  void Long(int64_t x) { s+= NumToString(x); }
-  void ULong(uint64_t x) { s+= NumToString(x); }
-  void Float(float x) { s+= NumToString(x); }
-  void Double(double x) { s+= NumToString(x); }
+  void Long(int64_t x) { s += NumToString(x); }
+  void ULong(uint64_t x) { s += NumToString(x); }
+  void Float(float x) { s += NumToString(x); }
+  void Double(double x) { s += NumToString(x); }
   void String(const struct String *str) {
     EscapeString(str->c_str(), str->size(), &s, true);
   }

include/flatbuffers/registry.h

@@ -37,17 +37,15 @@ class Registry {
 
   // Generate text from an arbitrary FlatBuffer by looking up its
   // file_identifier in the registry.
-  bool FlatBufferToText(const uint8_t *flatbuf, size_t len,
-                        std::string *dest) {
+  bool FlatBufferToText(const uint8_t *flatbuf, size_t len, std::string *dest) {
     // Get the identifier out of the buffer.
     // If the buffer is truncated, exit.
-    if (len < sizeof(uoffset_t) +
-              FlatBufferBuilder::kFileIdentifierLength) {
+    if (len < sizeof(uoffset_t) + FlatBufferBuilder::kFileIdentifierLength) {
       lasterror_ = "buffer truncated";
       return false;
     }
-    std::string ident(reinterpret_cast<const char *>(flatbuf) +
-                        sizeof(uoffset_t),
+    std::string ident(
+        reinterpret_cast<const char *>(flatbuf) + sizeof(uoffset_t),
         FlatBufferBuilder::kFileIdentifierLength);
     // Load and parse the schema.
     Parser parser;
@@ -82,9 +80,7 @@ class Registry {
 
   // If schemas used contain include statements, call this function for every
   // directory the parser should search them for.
-  void AddIncludeDirectory(const char *path) {
-    include_paths_.push_back(path);
-  }
+  void AddIncludeDirectory(const char *path) { include_paths_.push_back(path); }
 
   // Returns a human readable error if any of the above functions fail.
   const std::string &GetLastError() { return lasterror_; }

include/flatbuffers/stl_emulation.h

@@ -17,6 +17,8 @@
 #ifndef FLATBUFFERS_STL_EMULATION_H_
 #define FLATBUFFERS_STL_EMULATION_H_
 
+// clang-format off
+
 #include <string>
 #include <type_traits>
 #include <vector>

include/flatbuffers/util.h

@@ -17,32 +17,31 @@
 #ifndef FLATBUFFERS_UTIL_H_
 #define FLATBUFFERS_UTIL_H_
 
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
 #include <fstream>
 #include <iomanip>
-#include <string>
 #include <sstream>
-#include <stdint.h>
-#include <stdlib.h>
-#include <assert.h>
+#include <string>
 #ifdef _WIN32
-#ifndef WIN32_LEAN_AND_MEAN
-  #define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX
-  #define NOMINMAX
-#endif
-#include <windows.h>
-#include <winbase.h>
-#include <direct.h>
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  ifndef NOMINMAX
+#    define NOMINMAX
+#  endif
+#  include <direct.h>
+#  include <winbase.h>
+#  include <windows.h>
 #else
-#include <limits.h>
+#  include <limits.h>
 #endif
-#include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 
 #include "flatbuffers/base.h"
 
-
 namespace flatbuffers {
 
 // Convert an integer or floating point value to a string.
@@ -61,18 +60,18 @@ template<> inline std::string NumToString<unsigned char>(unsigned char t) {
   return NumToString(static_cast<int>(t));
 }
 #if defined(FLATBUFFERS_CPP98_STL)
-  template <> inline std::string NumToString<long long>(long long t) {
+template<> inline std::string NumToString<long long>(long long t) {
   char buf[21];  // (log((1 << 63) - 1) / log(10)) + 2
   snprintf(buf, sizeof(buf), "%lld", t);
   return std::string(buf);
-  }
+}
 
-  template <> inline std::string NumToString<unsigned long long>(
-      unsigned long long t) {
+template<>
+inline std::string NumToString<unsigned long long>(unsigned long long t) {
   char buf[22];  // (log((1 << 63) - 1) / log(10)) + 1
   snprintf(buf, sizeof(buf), "%llu", t);
   return std::string(buf);
-  }
+}
 #endif  // defined(FLATBUFFERS_CPP98_STL)
 
 // Special versions for floats/doubles.
@@ -100,10 +99,7 @@ template<> inline std::string NumToString<float>(float t) {
 // For example, IntToStringHex(0x23, 8) returns the string "00000023".
 inline std::string IntToStringHex(int i, int xdigits) {
   std::stringstream ss;
-  ss << std::setw(xdigits)
-     << std::setfill('0')
-     << std::hex
-     << std::uppercase
+  ss << std::setw(xdigits) << std::setfill('0') << std::hex << std::uppercase
      << i;
   return ss.str();
 }
@@ -111,21 +107,25 @@ inline std::string IntToStringHex(int i, int xdigits) {
 // Portable implementation of strtoll().
 inline int64_t StringToInt(const char *str, char **endptr = nullptr,
                            int base = 10) {
+  // clang-format off
   #ifdef _MSC_VER
     return _strtoi64(str, endptr, base);
   #else
     return strtoll(str, endptr, base);
   #endif
+  // clang-format on
 }
 
 // Portable implementation of strtoull().
 inline uint64_t StringToUInt(const char *str, char **endptr = nullptr,
                              int base = 10) {
+  // clang-format off
   #ifdef _MSC_VER
     return _strtoui64(str, endptr, base);
   #else
     return strtoull(str, endptr, base);
   #endif
+  // clang-format on
 }
 
 typedef bool (*LoadFileFunction)(const char *filename, bool binary,
@@ -134,9 +134,8 @@ typedef bool (*FileExistsFunction)(const char *filename);
 
 LoadFileFunction SetLoadFileFunction(LoadFileFunction load_file_function);
 
-FileExistsFunction SetFileExistsFunction(FileExistsFunction
-                                         file_exists_function);
-
+FileExistsFunction SetFileExistsFunction(
+    FileExistsFunction file_exists_function);
 
 // Check if file "name" exists.
 bool FileExists(const char *name);
@@ -239,16 +238,19 @@ inline std::string PosixPath(const char *path) {
 inline void EnsureDirExists(const std::string &filepath) {
   auto parent = StripFileName(filepath);
   if (parent.length()) EnsureDirExists(parent);
+    // clang-format off
   #ifdef _WIN32
     (void)_mkdir(filepath.c_str());
   #else
     mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP);
   #endif
+  // clang-format on
 }
 
 // Obtains the absolute path from any other path.
 // Returns the input path if the absolute path couldn't be resolved.
 inline std::string AbsolutePath(const std::string &filepath) {
+  // clang-format off
   #ifdef FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION
     return filepath;
   #else
@@ -262,6 +264,7 @@ inline std::string AbsolutePath(const std::string &filepath) {
       ? abs_path
       : filepath;
   #endif // FLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION
+  // clang-format on
 }
 
 // To and from UTF-8 unicode conversion functions
@@ -309,9 +312,7 @@ inline int FromUTF8(const char **in) {
   if ((**in << len) & 0x80) return -1;  // Bit after leading 1's must be 0.
   if (!len) return *(*in)++;
   // UTF-8 encoded values with a length are between 2 and 4 bytes.
-  if (len < 2 || len > 4) {
-    return -1;
-  }
+  if (len < 2 || len > 4) { return -1; }
   // Grab initial bits of the code.
   int ucc = *(*in)++ & ((1 << (7 - len)) - 1);
   for (int i = 0; i < len - 1; i++) {
@@ -321,28 +322,20 @@ inline int FromUTF8(const char **in) {
   }
   // UTF-8 cannot encode values between 0xD800 and 0xDFFF (reserved for
   // UTF-16 surrogate pairs).
-  if (ucc >= 0xD800 && ucc <= 0xDFFF) {
-    return -1;
-  }
+  if (ucc >= 0xD800 && ucc <= 0xDFFF) { return -1; }
   // UTF-8 must represent code points in their shortest possible encoding.
   switch (len) {
     case 2:
       // Two bytes of UTF-8 can represent code points from U+0080 to U+07FF.
-      if (ucc < 0x0080 || ucc > 0x07FF) {
-        return -1;
-      }
+      if (ucc < 0x0080 || ucc > 0x07FF) { return -1; }
       break;
     case 3:
       // Three bytes of UTF-8 can represent code points from U+0800 to U+FFFF.
-      if (ucc < 0x0800 || ucc > 0xFFFF) {
-        return -1;
-      }
+      if (ucc < 0x0800 || ucc > 0xFFFF) { return -1; }
       break;
     case 4:
       // Four bytes of UTF-8 can represent code points from U+10000 to U+10FFFF.
-      if (ucc < 0x10000 || ucc > 0x10FFFF) {
-        return -1;
-      }
+      if (ucc < 0x10000 || ucc > 0x10FFFF) { return -1; }
       break;
   }
   return ucc;
@@ -421,7 +414,8 @@ inline bool EscapeString(const char *s, size_t length, std::string *_text,
               text += "\\u";
               text += IntToStringHex(ucc, 4);
             } else if (ucc <= 0x10FFFF) {
-              // Encode Unicode SMP values to a surrogate pair using two \u escapes.
+              // Encode Unicode SMP values to a surrogate pair using two \u
+              // escapes.
               uint32_t base = ucc - 0x10000;
               auto high_surrogate = (base >> 10) + 0xD800;
               auto low_surrogate = (base & 0x03FF) + 0xDC00;

samples/sample_binary.cpp

@@ -20,7 +20,7 @@ using namespace MyGame::Sample;
 
 // Example how to use FlatBuffers to create and read binary buffers.
 
-int main(int /*argc*/, const char * /*argv*/[]) {
+int main(int /*argc*/, const char * /*argv*/ []) {
   // Build up a serialized buffer algorithmically:
   flatbuffers::FlatBufferBuilder builder;
 
@@ -83,8 +83,8 @@ int main(int /*argc*/, const char * /*argv*/[]) {
   (void)inv;
 
   // Get and test the `weapons` FlatBuffers's `vector`.
-  std::string expected_weapon_names[] = {"Sword", "Axe"};
-  short expected_weapon_damages[] = {3, 5};
+  std::string expected_weapon_names[] = { "Sword", "Axe" };
+  short expected_weapon_damages[] = { 3, 5 };
   auto weps = monster->weapons();
   for (unsigned int i = 0; i < weps->size(); i++) {
     assert(weps->Get(i)->name()->str() == expected_weapon_names[i]);
@@ -95,11 +95,10 @@ int main(int /*argc*/, const char * /*argv*/[]) {
 
   // Get and test the `Equipment` union (`equipped` field).
   assert(monster->equipped_type() == Equipment_Weapon);
-  auto equipped = static_cast<const Weapon*>(monster->equipped());
+  auto equipped = static_cast<const Weapon *>(monster->equipped());
   assert(equipped->name()->str() == "Axe");
   assert(equipped->damage() == 5);
   (void)equipped;
 
   printf("The FlatBuffer was successfully created and verified!\n");
 }
-

samples/sample_text.cpp

@@ -23,7 +23,7 @@ using namespace MyGame::Sample;
 
 // This is an example of parsing text straight into a buffer and then
 // generating flatbuffer (JSON) text from the buffer.
-int main(int /*argc*/, const char * /*argv*/[]) {
+int main(int /*argc*/, const char * /*argv*/ []) {
   // load FlatBuffer schema (.fbs) and JSON from disk
   std::string schemafile;
   std::string jsonfile;

src/clang-format.sh

+clang-format -i -style=file include/flatbuffers/* src/*.cpp tests/test.cpp samples/*.cpp grpc/src/compiler/schema_interface.h grpc/tests/*.cpp
+git checkout include/flatbuffers/reflection_generated.h

src/code_generators.cpp

@@ -20,24 +20,19 @@
 #include "flatbuffers/util.h"
 
 #if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4127) // C4127: conditional expression is constant
+#  pragma warning(push)
+#  pragma warning(disable : 4127)  // C4127: conditional expression is constant
 #endif
 
 namespace flatbuffers {
 
 void CodeWriter::operator+=(std::string text) {
-
   while (true) {
     auto begin = text.find("{{");
-    if (begin == std::string::npos) {
-      break;
-    }
+    if (begin == std::string::npos) { break; }
 
     auto end = text.find("}}");
-    if (end == std::string::npos || end < begin) {
-      break;
-    }
+    if (end == std::string::npos || end < begin) { break; }
 
     // Write all the text before the first {{ into the stream.
     stream_.write(text.c_str(), begin);
@@ -119,7 +114,6 @@ std::string BaseGenerator::WrapInNameSpace(const Namespace *ns,
   return qualified_name + name;
 }
 
-
 std::string BaseGenerator::WrapInNameSpace(const Definition &def) const {
   return WrapInNameSpace(def.defined_namespace, def.name);
 }
@@ -150,12 +144,12 @@ void GenComment(const std::vector<std::string> &dc, std::string *code_ptr,
   if (config != nullptr && config->first_line != nullptr) {
     code += std::string(prefix) + std::string(config->first_line) + "\n";
   }
-  std::string line_prefix = std::string(prefix) +
-      ((config != nullptr && config->content_line_prefix != nullptr) ?
-       config->content_line_prefix : "///");
-  for (auto it = dc.begin();
-       it != dc.end();
-       ++it) {
+  std::string line_prefix =
+      std::string(prefix) +
+      ((config != nullptr && config->content_line_prefix != nullptr)
+           ? config->content_line_prefix
+           : "///");
+  for (auto it = dc.begin(); it != dc.end(); ++it) {
     code += line_prefix + *it + "\n";
   }
   if (config != nullptr && config->last_line != nullptr) {
@@ -166,5 +160,5 @@ void GenComment(const std::vector<std::string> &dc, std::string *code_ptr,
 }  // namespace flatbuffers
 
 #if defined(_MSC_VER)
-#pragma warning(pop)
+#  pragma warning(pop)
 #endif

src/flatc_main.cpp

@@ -19,26 +19,17 @@
 static const char *g_program_name = nullptr;
 
 static void Warn(const flatbuffers::FlatCompiler *flatc,
-                 const std::string &warn,
-                 bool show_exe_name) {
+                 const std::string &warn, bool show_exe_name) {
   (void)flatc;
-  if (show_exe_name) {
-    printf("%s: ", g_program_name);
-  }
+  if (show_exe_name) { printf("%s: ", g_program_name); }
   printf("warning: %s\n", warn.c_str());
 }
 
 static void Error(const flatbuffers::FlatCompiler *flatc,
-                  const std::string &err,
-                  bool usage,
-                  bool show_exe_name) {
-  if (show_exe_name) {
-    printf("%s: ", g_program_name);
-  }
+                  const std::string &err, bool usage, bool show_exe_name) {
+  if (show_exe_name) { printf("%s: ", g_program_name); }
   printf("error: %s\n", err.c_str());
-  if (usage) {
-    printf("%s", flatc->GetUsageString(g_program_name).c_str());
-  }
+  if (usage) { printf("%s", flatc->GetUsageString(g_program_name).c_str()); }
   exit(1);
 }
 
@@ -46,61 +37,43 @@ int main(int argc, const char *argv[]) {
   g_program_name = argv[0];
 
   const flatbuffers::FlatCompiler::Generator generators[] = {
-    { flatbuffers::GenerateBinary,   "-b", "--binary", "binary", false,
-      nullptr,
+    { flatbuffers::GenerateBinary, "-b", "--binary", "binary", false, nullptr,
       flatbuffers::IDLOptions::kBinary,
       "Generate wire format binaries for any data definitions",
       flatbuffers::BinaryMakeRule },
-    { flatbuffers::GenerateTextFile, "-t", "--json", "text", false,
-      nullptr,
+    { flatbuffers::GenerateTextFile, "-t", "--json", "text", false, nullptr,
       flatbuffers::IDLOptions::kJson,
       "Generate text output for any data definitions",
       flatbuffers::TextMakeRule },
     { flatbuffers::GenerateCPP, "-c", "--cpp", "C++", true,
-      flatbuffers::GenerateCppGRPC,
-      flatbuffers::IDLOptions::kCpp,
-      "Generate C++ headers for tables/structs",
-      flatbuffers::CPPMakeRule },
+      flatbuffers::GenerateCppGRPC, flatbuffers::IDLOptions::kCpp,
+      "Generate C++ headers for tables/structs", flatbuffers::CPPMakeRule },
     { flatbuffers::GenerateGo, "-g", "--go", "Go", true,
-      flatbuffers::GenerateGoGRPC,
-      flatbuffers::IDLOptions::kGo,
-      "Generate Go files for tables/structs",
-      flatbuffers::GeneralMakeRule },
+      flatbuffers::GenerateGoGRPC, flatbuffers::IDLOptions::kGo,
+      "Generate Go files for tables/structs", flatbuffers::GeneralMakeRule },
     { flatbuffers::GenerateGeneral, "-j", "--java", "Java", true,
-      flatbuffers::GenerateJavaGRPC,
-      flatbuffers::IDLOptions::kJava,
+      flatbuffers::GenerateJavaGRPC, flatbuffers::IDLOptions::kJava,
       "Generate Java classes for tables/structs",
       flatbuffers::GeneralMakeRule },
-    { flatbuffers::GenerateJS,       "-s", "--js", "JavaScript", true,
-      nullptr,
+    { flatbuffers::GenerateJS, "-s", "--js", "JavaScript", true, nullptr,
       flatbuffers::IDLOptions::kJs,
-      "Generate JavaScript code for tables/structs",
-      flatbuffers::JSMakeRule },
-    { flatbuffers::GenerateJS,       "-T", "--ts", "TypeScript", true,
-      nullptr,
+      "Generate JavaScript code for tables/structs", flatbuffers::JSMakeRule },
+    { flatbuffers::GenerateJS, "-T", "--ts", "TypeScript", true, nullptr,
       flatbuffers::IDLOptions::kTs,
-      "Generate TypeScript code for tables/structs",
-      flatbuffers::JSMakeRule },
-    { flatbuffers::GenerateGeneral,  "-n", "--csharp", "C#", true,
-      nullptr,
+      "Generate TypeScript code for tables/structs", flatbuffers::JSMakeRule },
+    { flatbuffers::GenerateGeneral, "-n", "--csharp", "C#", true, nullptr,
       flatbuffers::IDLOptions::kCSharp,
-      "Generate C# classes for tables/structs",
-      flatbuffers::GeneralMakeRule },
-    { flatbuffers::GeneratePython,   "-p", "--python", "Python", true,
-      nullptr,
+      "Generate C# classes for tables/structs", flatbuffers::GeneralMakeRule },
+    { flatbuffers::GeneratePython, "-p", "--python", "Python", true, nullptr,
       flatbuffers::IDLOptions::kPython,
       "Generate Python files for tables/structs",
       flatbuffers::GeneralMakeRule },
-    { flatbuffers::GeneratePhp, nullptr, "--php", "PHP", true,
-      nullptr,
-      flatbuffers::IDLOptions::kPhp,
-      "Generate PHP files for tables/structs",
-      flatbuffers::GeneralMakeRule },
-   { flatbuffers::GenerateJsonSchema, nullptr, "--jsonschema", "JsonSchema", true,
-      nullptr,
-      flatbuffers::IDLOptions::kJsonSchema,
-      "Generate Json schema",
+    { flatbuffers::GeneratePhp, nullptr, "--php", "PHP", true, nullptr,
+      flatbuffers::IDLOptions::kPhp, "Generate PHP files for tables/structs",
       flatbuffers::GeneralMakeRule },
+    { flatbuffers::GenerateJsonSchema, nullptr, "--jsonschema", "JsonSchema",
+      true, nullptr, flatbuffers::IDLOptions::kJsonSchema,
+      "Generate Json schema", flatbuffers::GeneralMakeRule },
   };
 
   flatbuffers::FlatCompiler::InitParams params;

src/flathash.cpp

@@ -14,20 +14,16 @@
  * limitations under the License.
  */
 
+#include <stdio.h>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include "flatbuffers/hash.h"
-#include <stdio.h>
 
-enum OutputFormat {
-  kDecimal,
-  kHexadecimal,
-  kHexadecimal0x
-};
+enum OutputFormat { kDecimal, kHexadecimal, kHexadecimal0x };
 
-int main(int argc, char* argv[]) {
-  const char* name = argv[0];
+int main(int argc, char *argv[]) {
+  const char *name = argv[0];
   if (argc <= 1) {
     printf("%s HASH [OPTION]... STRING... [-- STRING...]\n", name);
     printf("Available hashing algorithms:\n  32 bit:\n");
@@ -50,7 +46,7 @@ int main(int argc, char* argv[]) {
     return 0;
   }
 
-  const char* hash_algorithm = argv[1];
+  const char *hash_algorithm = argv[1];
 
   flatbuffers::NamedHashFunction<uint32_t>::HashFunction hash_function32 =
       flatbuffers::FindHashFunction32(hash_algorithm);
@@ -66,15 +62,21 @@ int main(int argc, char* argv[]) {
   bool annotate = false;
   bool escape_dash = false;
   for (int i = 2; i < argc; i++) {
-    const char* arg = argv[i];
+    const char *arg = argv[i];
     if (!escape_dash && arg[0] == '-') {
       std::string opt = arg;
-      if (opt == "-d")       output_format = kDecimal;
-      else if (opt == "-x")  output_format = kHexadecimal;
-      else if (opt == "-0x") output_format = kHexadecimal0x;
-      else if (opt == "-c")  annotate = true;
-      else if (opt == "--")  escape_dash = true;
-      else printf("Unrecognized argument: \"%s\"\n", arg);
+      if (opt == "-d")
+        output_format = kDecimal;
+      else if (opt == "-x")
+        output_format = kHexadecimal;
+      else if (opt == "-0x")
+        output_format = kHexadecimal0x;
+      else if (opt == "-c")
+        annotate = true;
+      else if (opt == "--")
+        escape_dash = true;
+      else
+        printf("Unrecognized argument: \"%s\"\n", arg);
     } else {
       std::stringstream ss;
       if (output_format == kDecimal) {
@@ -90,8 +92,7 @@ int main(int argc, char* argv[]) {
       else if (hash_function64)
         ss << hash_function64(arg);
 
-      if (annotate)
-        ss << " /* \"" << arg << "\" */";
+      if (annotate) ss << " /* \"" << arg << "\" */";
 
       ss << "\n";
 
@@ -100,4 +101,3 @@ int main(int argc, char* argv[]) {
   }
   return 0;
 }
-

src/idl_gen_fbs.cpp

@@ -16,10 +16,10 @@
 
 // independent from idl_parser, since this code is not needed for most clients
 
+#include "flatbuffers/code_generators.h"
 #include "flatbuffers/flatbuffers.h"
 #include "flatbuffers/idl.h"
 #include "flatbuffers/util.h"
-#include "flatbuffers/code_generators.h"
 
 namespace flatbuffers {
 
@@ -28,8 +28,7 @@ static std::string GenType(const Type &type, bool underlying = false) {
     case BASE_TYPE_STRUCT:
       return type.struct_def->defined_namespace->GetFullyQualifiedName(
           type.struct_def->name);
-    case BASE_TYPE_VECTOR:
-        return "[" + GenType(type.VectorType()) + "]";
+    case BASE_TYPE_VECTOR: return "[" + GenType(type.VectorType()) + "]";
     default:
       if (type.enum_def && !underlying) {
         return type.enum_def->defined_namespace->GetFullyQualifiedName(
@@ -69,6 +68,7 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) {
   std::string schema;
   schema += "// Generated from " + file_name + ".proto\n\n";
   if (parser.opts.include_dependence_headers) {
+    // clang-format off
     #ifdef FBS_GEN_INCLUDES  // TODO: currently all in one file.
     int num_includes = 0;
     for (auto it = parser.included_files_.begin();
@@ -82,6 +82,7 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) {
     }
     if (num_includes) schema += "\n";
     #endif
+    // clang-format on
   }
   // Generate code for all the enum declarations.
   const Namespace *last_namespace = nullptr;
@@ -92,8 +93,8 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) {
     GenComment(enum_def.doc_comment, &schema, nullptr);
     schema += "enum " + enum_def.name + " : ";
     schema += GenType(enum_def.underlying_type, true) + " {\n";
-    for (auto it = enum_def.vals.vec.begin();
-         it != enum_def.vals.vec.end(); ++it) {
+    for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+         ++it) {
       auto &ev = **it;
       GenComment(ev.doc_comment, &schema, nullptr, "  ");
       schema += "  " + ev.name + " = " + NumToString(ev.value) + ",\n";
@@ -101,8 +102,8 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) {
     schema += "}\n\n";
   }
   // Generate code for all structs/tables.
-  for (auto it = parser.structs_.vec.begin();
-           it != parser.structs_.vec.end(); ++it) {
+  for (auto it = parser.structs_.vec.begin(); it != parser.structs_.vec.end();
+       ++it) {
     StructDef &struct_def = **it;
     GenNameSpace(*struct_def.defined_namespace, &schema, &last_namespace);
     GenComment(struct_def.doc_comment, &schema, nullptr);
@@ -123,12 +124,10 @@ std::string GenerateFBS(const Parser &parser, const std::string &file_name) {
   return schema;
 }
 
-bool GenerateFBS(const Parser &parser,
-                 const std::string &path,
+bool GenerateFBS(const Parser &parser, const std::string &path,
                  const std::string &file_name) {
   return SaveFile((path + file_name + ".fbs").c_str(),
                   GenerateFBS(parser, file_name), false);
 }
 
 }  // namespace flatbuffers
-

src/idl_gen_json_schema.cpp

 /*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
+#include <iostream>
 #include "flatbuffers/code_generators.h"
 #include "flatbuffers/idl.h"
 #include "flatbuffers/util.h"
-#include <iostream>
 
 namespace flatbuffers {
 
@@ -30,8 +30,7 @@ namespace jsons {
 
 std::string GenNativeType(BaseType type) {
   switch (type) {
-    case BASE_TYPE_BOOL:
-      return "boolean";
+    case BASE_TYPE_BOOL: return "boolean";
     case BASE_TYPE_CHAR:
     case BASE_TYPE_UCHAR:
     case BASE_TYPE_SHORT:
@@ -41,16 +40,13 @@ std::string GenNativeType(BaseType type) {
     case BASE_TYPE_LONG:
     case BASE_TYPE_ULONG:
     case BASE_TYPE_FLOAT:
-    case BASE_TYPE_DOUBLE:
-      return "number";
-    case BASE_TYPE_STRING:
-      return "string";
-    default:
-      return "";
+    case BASE_TYPE_DOUBLE: return "number";
+    case BASE_TYPE_STRING: return "string";
+    default: return "";
   }
 }
 
-template <class T> std::string GenFullName(const T *enum_def) {
+template<class T> std::string GenFullName(const T *enum_def) {
   std::string full_name;
   const auto &name_spaces = enum_def->defined_namespace->components;
   for (auto ns = name_spaces.cbegin(); ns != name_spaces.cend(); ++ns) {
@@ -60,7 +56,7 @@ template <class T> std::string GenFullName(const T *enum_def) {
   return full_name;
 }
 
-template <class T> std::string GenTypeRef(const T *enum_def) {
+template<class T> std::string GenTypeRef(const T *enum_def) {
   return "\"$ref\" : \"#/definitions/" + GenFullName(enum_def) + "\"";
 }
 
@@ -93,11 +89,10 @@ std::string GenType(const Type &type) {
       const auto &union_types = type.enum_def->vals.vec;
       for (auto ut = union_types.cbegin(); ut < union_types.cend(); ++ut) {
         auto &union_type = *ut;
-        if (union_type->union_type.base_type == BASE_TYPE_NONE) {
-          continue;
-        }
+        if (union_type->union_type.base_type == BASE_TYPE_NONE) { continue; }
         if (union_type->union_type.base_type == BASE_TYPE_STRUCT) {
-          union_type_string.append("{ " + GenTypeRef(union_type->union_type.struct_def) + " }");
+          union_type_string.append(
+              "{ " + GenTypeRef(union_type->union_type.struct_def) + " }");
         }
         if (union_type != *type.enum_def->vals.vec.rbegin()) {
           union_type_string.append(",");
@@ -106,10 +101,8 @@ std::string GenType(const Type &type) {
       union_type_string.append("]");
       return union_type_string;
     }
-    case BASE_TYPE_UTYPE:
-      return GenTypeRef(type.enum_def);
-    default:
-      return GenType(GenNativeType(type.base_type));
+    case BASE_TYPE_UTYPE: return GenTypeRef(type.enum_def);
+    default: return GenType(GenNativeType(type.base_type));
   }
 }
 
@@ -130,35 +123,29 @@ class JsonSchemaGenerator : public BaseGenerator {
     code_ += "{";
     code_ += "  \"$schema\": \"http://json-schema.org/draft-04/schema#\",";
     code_ += "  \"definitions\": {";
-    for (auto e = parser_.enums_.vec.cbegin();
-         e != parser_.enums_.vec.cend();
+    for (auto e = parser_.enums_.vec.cbegin(); e != parser_.enums_.vec.cend();
          ++e) {
       code_ += "    \"" + GenFullName(*e) + "\" : {";
       code_ += "      " + GenType("string") + ",";
       std::string enumdef("      \"enum\": [");
       for (auto enum_value = (*e)->vals.vec.begin();
-           enum_value != (*e)->vals.vec.end();
-           ++enum_value) {
+           enum_value != (*e)->vals.vec.end(); ++enum_value) {
         enumdef.append("\"" + (*enum_value)->name + "\"");
-        if (*enum_value != (*e)->vals.vec.back()) {
-          enumdef.append(", ");
-        }
+        if (*enum_value != (*e)->vals.vec.back()) { enumdef.append(", "); }
       }
       enumdef.append("]");
       code_ += enumdef;
       code_ += "    },";  // close type
     }
     for (auto s = parser_.structs_.vec.cbegin();
-         s != parser_.structs_.vec.cend();
-         ++s) {
+         s != parser_.structs_.vec.cend(); ++s) {
       const auto &structure = *s;
       code_ += "    \"" + GenFullName(structure) + "\" : {";
       code_ += "      " + GenType("object") + ",";
       std::string comment;
       const auto &comment_lines = structure->doc_comment;
       for (auto comment_line = comment_lines.cbegin();
-           comment_line != comment_lines.cend();
-           ++comment_line) {
+           comment_line != comment_lines.cend(); ++comment_line) {
         comment.append(*comment_line);
       }
       if (comment.size() > 0) {
@@ -169,10 +156,9 @@ class JsonSchemaGenerator : public BaseGenerator {
       const auto &properties = structure->fields.vec;
       for (auto prop = properties.cbegin(); prop != properties.cend(); ++prop) {
         const auto &property = *prop;
-        std::string typeLine("        \"" + property->name + "\" : { " + GenType(property->value.type) + " }");
-        if (property != properties.back()) {
-          typeLine.append(",");
-        }          
+        std::string typeLine("        \"" + property->name + "\" : { " +
+                             GenType(property->value.type) + " }");
+        if (property != properties.back()) { typeLine.append(","); }
         code_ += typeLine;
       }
       code_ += "      },";  // close properties
@@ -184,8 +170,7 @@ class JsonSchemaGenerator : public BaseGenerator {
       if (requiredProperties.size() > 0) {
         std::string required_string("      \"required\" : [");
         for (auto req_prop = requiredProperties.cbegin();
-             req_prop != requiredProperties.cend();
-             ++req_prop) {
+             req_prop != requiredProperties.cend(); ++req_prop) {
           required_string.append("\"" + (*req_prop)->name + "\"");
           if (*req_prop != requiredProperties.back()) {
             required_string.append(", ");
@@ -196,9 +181,7 @@ class JsonSchemaGenerator : public BaseGenerator {
       }
       code_ += "      \"additionalProperties\" : false";
       std::string closeType("    }");
-      if (*s != parser_.structs_.vec.back()) {
-        closeType.append(",");
-      }
+      if (*s != parser_.structs_.vec.back()) { closeType.append(","); }
       code_ += closeType;  // close type
     }
     code_ += "  },";  // close definitions