google · dbaileychess · Dec 19, 2025 · Dec 19, 2025
@@ -15,25 +15,27 @@
  */
 
 #include <jni.h>
-#include <string>
 #include <search.h>
+
+#include <string>
+
 #include "generated/animal_generated.h"
 
 using namespace com::fbs::app;
 using namespace flatbuffers;
 
-extern "C" JNIEXPORT jbyteArray JNICALL Java_com_flatbuffers_app_MainActivity_createAnimalFromJNI(
-        JNIEnv* env,
-        jobject /* this */) {
-    // create a new animal flatbuffers
-    auto fb = FlatBufferBuilder(1024);
-    auto tiger = CreateAnimalDirect(fb, "Tiger", "Roar", 300);
-    fb.Finish(tiger);
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_flatbuffers_app_MainActivity_createAnimalFromJNI(JNIEnv* env,
+                                                          jobject /* this */) {
+  // create a new animal flatbuffers
+  auto fb = FlatBufferBuilder(1024);
+  auto tiger = CreateAnimalDirect(fb, "Tiger", "Roar", 300);
+  fb.Finish(tiger);
 
-    // copies it to a Java byte array.
-    auto buf = reinterpret_cast<jbyte*>(fb.GetBufferPointer());
-    int size = fb.GetSize();
-    auto ret = env->NewByteArray(size);
-    env->SetByteArrayRegion (ret, 0, fb.GetSize(), buf);
+  // copies it to a Java byte array.
+  auto buf = reinterpret_cast<jbyte*>(fb.GetBufferPointer());
+  int size = fb.GetSize();
+  auto ret = env->NewByteArray(size);
+  env->SetByteArrayRegion(ret, 0, fb.GetSize(), buf);
   return ret;
 }
@@ -5,40 +5,42 @@
 #include "benchmarks/cpp/flatbuffers/fb_bench.h"
 #include "benchmarks/cpp/raw/raw_bench.h"
 
-static inline void Encode(benchmark::State &state,
-                          std::unique_ptr<Bench> &bench, uint8_t *buffer) {
+static inline void Encode(benchmark::State& state,
+                          std::unique_ptr<Bench>& bench, uint8_t* buffer) {
   int64_t length;
   for (auto _ : state) {
     bench->Encode(buffer, length);
     benchmark::DoNotOptimize(length);
   }
 }
 
-static inline void Decode(benchmark::State &state,
-                          std::unique_ptr<Bench> &bench, uint8_t *buffer) {
+static inline void Decode(benchmark::State& state,
+                          std::unique_ptr<Bench>& bench, uint8_t* buffer) {
   int64_t length;
-  uint8_t *encoded = bench->Encode(buffer, length);
+  uint8_t* encoded = bench->Encode(buffer, length);
 
   for (auto _ : state) {
-    void *decoded = bench->Decode(encoded, length);
+    void* decoded = bench->Decode(encoded, length);
     benchmark::DoNotOptimize(decoded);
   }
 }
 
-static inline void Use(benchmark::State &state, std::unique_ptr<Bench> &bench,
-                       uint8_t *buffer, int64_t check_sum) {
+static inline void Use(benchmark::State& state, std::unique_ptr<Bench>& bench,
+                       uint8_t* buffer, int64_t check_sum) {
   int64_t length;
-  uint8_t *encoded = bench->Encode(buffer, length);
-  void *decoded = bench->Decode(encoded, length);
+  uint8_t* encoded = bench->Encode(buffer, length);
+  void* decoded = bench->Decode(encoded, length);
 
   int64_t sum = 0;
 
-  for (auto _ : state) { sum = bench->Use(decoded); }
+  for (auto _ : state) {
+    sum = bench->Use(decoded);
+  }
 
   EXPECT_EQ(sum, check_sum);
 }
 
-static void BM_Flatbuffers_Encode(benchmark::State &state) {
+static void BM_Flatbuffers_Encode(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 
@@ -48,7 +50,7 @@ static void BM_Flatbuffers_Encode(benchmark::State &state) {
 }
 BENCHMARK(BM_Flatbuffers_Encode);
 
-static void BM_Flatbuffers_Decode(benchmark::State &state) {
+static void BM_Flatbuffers_Decode(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 
@@ -58,7 +60,7 @@ static void BM_Flatbuffers_Decode(benchmark::State &state) {
 }
 BENCHMARK(BM_Flatbuffers_Decode);
 
-static void BM_Flatbuffers_Use(benchmark::State &state) {
+static void BM_Flatbuffers_Use(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 
@@ -68,7 +70,7 @@ static void BM_Flatbuffers_Use(benchmark::State &state) {
 }
 BENCHMARK(BM_Flatbuffers_Use);
 
-static void BM_Raw_Encode(benchmark::State &state) {
+static void BM_Raw_Encode(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 
@@ -77,7 +79,7 @@ static void BM_Raw_Encode(benchmark::State &state) {
 }
 BENCHMARK(BM_Raw_Encode);
 
-static void BM_Raw_Decode(benchmark::State &state) {
+static void BM_Raw_Decode(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 
@@ -86,7 +88,7 @@ static void BM_Raw_Decode(benchmark::State &state) {
 }
 BENCHMARK(BM_Raw_Decode);
 
-static void BM_Raw_Use(benchmark::State &state) {
+static void BM_Raw_Use(benchmark::State& state) {
   const int64_t kBufferLength = 1024;
   uint8_t buffer[kBufferLength];
 

@@ -13,10 +13,10 @@ using namespace benchmarks_flatbuffers;
 namespace {
 
 struct FlatBufferBench : Bench {
-  explicit FlatBufferBench(int64_t initial_size, Allocator *allocator)
+  explicit FlatBufferBench(int64_t initial_size, Allocator* allocator)
       : fbb(initial_size, allocator, false) {}
 
-  uint8_t *Encode(void *, int64_t &len) override {
+  uint8_t* Encode(void*, int64_t& len) override {
     fbb.Clear();
 
     const int kVectorLength = 3;
@@ -40,7 +40,7 @@ struct FlatBufferBench : Bench {
     return fbb.GetBufferPointer();
   }
 
-  int64_t Use(void *decoded) override {
+  int64_t Use(void* decoded) override {
     sum = 0;
     auto foobarcontainer = GetFooBarContainer(decoded);
     sum = 0;
@@ -56,7 +56,7 @@ struct FlatBufferBench : Bench {
       Add(static_cast<int64_t>(bar->ratio()));
       Add(bar->size());
       Add(bar->time());
-      auto &foo = bar->parent();
+      auto& foo = bar->parent();
       Add(foo.count());
       Add(foo.id());
       Add(foo.length());
@@ -65,16 +65,16 @@ struct FlatBufferBench : Bench {
     return sum;
   }
 
-  void *Decode(void *buffer, int64_t) override { return buffer; }
-  void Dealloc(void *) override {};
+  void* Decode(void* buffer, int64_t) override { return buffer; }
+  void Dealloc(void*) override {};
 
   FlatBufferBuilder fbb;
 };
 
 }  // namespace
 
 std::unique_ptr<Bench> NewFlatBuffersBench(int64_t initial_size,
-                                           Allocator *allocator) {
+                                           Allocator* allocator) {
   return std::unique_ptr<FlatBufferBench>(
       new FlatBufferBench(initial_size, allocator));
 }
@@ -45,37 +45,37 @@ struct FooBarContainer {
 };
 
 struct RawBench : Bench {
-  uint8_t *Encode(void *buf, int64_t &len) override {
-    FooBarContainer *fbc = new (buf) FooBarContainer;
+  uint8_t* Encode(void* buf, int64_t& len) override {
+    FooBarContainer* fbc = new (buf) FooBarContainer;
     strcpy(fbc->location, "http://google.com/flatbuffers/");  // Unsafe eek!
     fbc->location_len = (int)strlen(fbc->location);
     fbc->fruit = Bananas;
     fbc->initialized = true;
     for (int i = 0; i < kVectorLength; i++) {
       // We add + i to not make these identical copies for a more realistic
       // compression test.
-      auto &foobar = fbc->list[i];
+      auto& foobar = fbc->list[i];
       foobar.rating = 3.1415432432445543543 + i;
       foobar.postfix = '!' + i;
       strcpy(foobar.name, "Hello, World!");
       foobar.name_len = (int)strlen(foobar.name);
-      auto &bar = foobar.sibling;
+      auto& bar = foobar.sibling;
       bar.ratio = 3.14159f + i;
       bar.size = 10000 + i;
       bar.time = 123456 + i;
-      auto &foo = bar.parent;
+      auto& foo = bar.parent;
       foo.id = 0xABADCAFEABADCAFE + i;
       foo.count = 10000 + i;
       foo.length = 1000000 + i;
       foo.prefix = '@' + i;
     }
 
     len = sizeof(FooBarContainer);
-    return reinterpret_cast<uint8_t *>(fbc);
+    return reinterpret_cast<uint8_t*>(fbc);
   };
 
-  int64_t Use(void *decoded) override {
-    auto foobarcontainer = reinterpret_cast<FooBarContainer *>(decoded);
+  int64_t Use(void* decoded) override {
+    auto foobarcontainer = reinterpret_cast<FooBarContainer*>(decoded);
     sum = 0;
     Add(foobarcontainer->initialized);
     Add(foobarcontainer->location_len);
@@ -89,7 +89,7 @@ struct RawBench : Bench {
       Add(static_cast<int64_t>(bar->ratio));
       Add(bar->size);
       Add(bar->time);
-      auto &foo = bar->parent;
+      auto& foo = bar->parent;
       Add(foo.count);
       Add(foo.id);
       Add(foo.length);
@@ -98,8 +98,8 @@ struct RawBench : Bench {
     return sum;
   }
 
-  void *Decode(void *buf, int64_t) override { return buf; }
-  void Dealloc(void *) override{};
+  void* Decode(void* buf, int64_t) override { return buf; }
+  void Dealloc(void*) override {};
 };
 
 }  // namespace

@@ -1,18 +1,18 @@
-#include "greeter.grpc.fb.h"
-#include "greeter_generated.h"
-
 #include <grpcpp/grpcpp.h>
 
 #include <iostream>
 #include <memory>
 #include <string>
 
+#include "greeter.grpc.fb.h"
+#include "greeter_generated.h"
+
 class GreeterClient {
  public:
   GreeterClient(std::shared_ptr<grpc::Channel> channel)
-    : stub_(Greeter::NewStub(channel)) {}
+      : stub_(Greeter::NewStub(channel)) {}
 
-  std::string SayHello(const std::string &name) {
+  std::string SayHello(const std::string& name) {
     flatbuffers::grpc::MessageBuilder mb;
     auto name_offset = mb.CreateString(name);
     auto request_offset = CreateHelloRequest(mb, name_offset);
@@ -25,7 +25,7 @@ class GreeterClient {
 
     auto status = stub_->SayHello(&context, request_msg, &response_msg);
     if (status.ok()) {
-      const HelloReply *response = response_msg.GetRoot();
+      const HelloReply* response = response_msg.GetRoot();
       return response->message()->str();
     } else {
       std::cerr << status.error_code() << ": " << status.error_message()
@@ -34,8 +34,8 @@ class GreeterClient {
     }
   }
 
-  void SayManyHellos(const std::string &name, int num_greetings,
-                     std::function<void(const std::string &)> callback) {
+  void SayManyHellos(const std::string& name, int num_greetings,
+                     std::function<void(const std::string&)> callback) {
     flatbuffers::grpc::MessageBuilder mb;
     auto name_offset = mb.CreateString(name);
     auto request_offset =
@@ -49,7 +49,7 @@ class GreeterClient {
 
     auto stream = stub_->SayManyHellos(&context, request_msg);
     while (stream->Read(&response_msg)) {
-      const HelloReply *response = response_msg.GetRoot();
+      const HelloReply* response = response_msg.GetRoot();
       callback(response->message()->str());
     }
     auto status = stream->Finish();
@@ -64,7 +64,7 @@ class GreeterClient {
   std::unique_ptr<Greeter::Stub> stub_;
 };
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   std::string server_address("localhost:50051");
 
   auto channel =
@@ -77,7 +77,7 @@ int main(int argc, char **argv) {
   std::cerr << "Greeter received: " << message << std::endl;
 
   int num_greetings = 10;
-  greeter.SayManyHellos(name, num_greetings, [](const std::string &message) {
+  greeter.SayManyHellos(name, num_greetings, [](const std::string& message) {
     std::cerr << "Greeter received: " << message << std::endl;
   });
 

@@ -1,25 +1,25 @@
-#include "greeter.grpc.fb.h"
-#include "greeter_generated.h"
-
 #include <grpcpp/grpcpp.h>
 
 #include <iostream>
 #include <memory>
 #include <string>
 
+#include "greeter.grpc.fb.h"
+#include "greeter_generated.h"
+
 class GreeterServiceImpl final : public Greeter::Service {
   virtual grpc::Status SayHello(
-      grpc::ServerContext *context,
-      const flatbuffers::grpc::Message<HelloRequest> *request_msg,
-      flatbuffers::grpc::Message<HelloReply> *response_msg) override {
+      grpc::ServerContext* context,
+      const flatbuffers::grpc::Message<HelloRequest>* request_msg,
+      flatbuffers::grpc::Message<HelloReply>* response_msg) override {
     flatbuffers::grpc::MessageBuilder mb_;
 
     // We call GetRoot to "parse" the message. Verification is already
     // performed by default. See the notes below for more details.
-    const HelloRequest *request = request_msg->GetRoot();
+    const HelloRequest* request = request_msg->GetRoot();
 
     // Fields are retrieved as usual with FlatBuffers
-    const std::string &name = request->name()->str();
+    const std::string& name = request->name()->str();
 
     // `flatbuffers::grpc::MessageBuilder` is a `FlatBufferBuilder` with a
     // special allocator for efficient gRPC buffer transfer, but otherwise
@@ -39,14 +39,14 @@ class GreeterServiceImpl final : public Greeter::Service {
   }
 
   virtual grpc::Status SayManyHellos(
-      grpc::ServerContext *context,
-      const flatbuffers::grpc::Message<ManyHellosRequest> *request_msg,
-      grpc::ServerWriter<flatbuffers::grpc::Message<HelloReply>> *writer)
+      grpc::ServerContext* context,
+      const flatbuffers::grpc::Message<ManyHellosRequest>* request_msg,
+      grpc::ServerWriter<flatbuffers::grpc::Message<HelloReply>>* writer)
       override {
     // The streaming usage below is simply a combination of standard gRPC
     // streaming with the FlatBuffers usage shown above.
-    const ManyHellosRequest *request = request_msg->GetRoot();
-    const std::string &name = request->name()->str();
+    const ManyHellosRequest* request = request_msg->GetRoot();
+    const std::string& name = request->name()->str();
     int num_greetings = request->num_greetings();
 
     for (int i = 0; i < num_greetings; i++) {
@@ -75,7 +75,7 @@ void RunServer() {
   server->Wait();
 }
 
-int main(int argc, const char *argv[]) {
+int main(int argc, const char* argv[]) {
   RunServer();
   return 0;
 }