update files with new formatting

Author: StephanKa

fuzz_test/fuzz_tester.cpp

@@ -1,22 +1,20 @@
+#include <fmt/format.h>
 #include <iterator>
 #include <utility>
-#include <fmt/format.h>
 
 [[nodiscard]] auto sum_values(const uint8_t *Data, size_t Size)
 {
-  constexpr auto scale = 1000;
+    constexpr auto scale = 1000;
 
-  int value = 0;
-  for (std::size_t offset = 0; offset < Size; ++offset) {
-    value += static_cast<int>(*std::next(Data, static_cast<long>(offset))) * scale;
-  }
-  return value;
+    int value = 0;
+    for (std::size_t offset = 0; offset < Size; ++offset) { value += static_cast<int>(*std::next(Data, static_cast<long>(offset))) * scale; }
+    return value;
 }
 
 // Fuzzer that attempts to invoke undefined behavior for signed integer overflow
 // cppcheck-suppress unusedFunction symbolName=LLVMFuzzerTestOneInput
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
 {
-  fmt::print("Value sum: {}, len{}\n", sum_values(Data,Size), Size);
-  return 0;
+    fmt::print("Value sum: {}, len{}\n", sum_values(Data, Size), Size);
+    return 0;
 }

src/boost.beast/data.h

@@ -8,8 +8,8 @@ struct person
 {
     std::string name;
     std::string address;
-    int age = {0};
-    int id = {0};
+    int age = { 0 };
+    int id = { 0 };
 };
 
 inline void to_json(nlohmann::json &j, const person &p) { j = nlohmann::json{ { "name", p.name }, { "address", p.address }, { "age", p.age }, { "id", p.id } }; }

src/boost.beast/error_handling.h

@@ -1,9 +1,9 @@
 #pragma once
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 #include <boost/beast/version.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <boost/asio/strand.hpp>
 #include <fmt/format.h>
 
 // from <boost/beast.hpp>

src/boost.beast/listener.h

@@ -1,6 +1,6 @@
 #pragma once
-#include "error_handling.h"
 #include "data.h"
+#include "error_handling.h"
 #include "session.h"
 
 // Accepts incoming connections and launches the sessions
@@ -13,32 +13,28 @@ class Listener : public std::enable_shared_from_this<Listener>
 
         // Open the acceptor
         m_acceptor.open(endpoint.protocol(), ec);
-        if (ec)
-        {
+        if (ec) {
             fail(ec, "open");
             return;
         }
 
         // Allow address reuse
         m_acceptor.set_option(asio::socket_base::reuse_address(true), ec);
-        if (ec)
-        {
+        if (ec) {
             fail(ec, "set_option");
             return;
         }
 
         // Bind to the server address
         m_acceptor.bind(endpoint, ec);
-        if (ec)
-        {
+        if (ec) {
             fail(ec, "bind");
             return;
         }
 
         // Start listening for connections
         m_acceptor.listen(asio::socket_base::max_listen_connections, ec);
-        if (ec)
-        {
+        if (ec) {
             fail(ec, "listen");
             return;
         }
@@ -56,12 +52,9 @@ class Listener : public std::enable_shared_from_this<Listener>
 
     void onAccept(beast::error_code ec, tcp::socket socket)
     {
-        if (ec)
-        {
+        if (ec) {
             fail(ec, "accept");
-        }
-        else
-        {
+        } else {
             // Create the session and run it
             std::make_shared<Session>(std::move(socket), m_persons)->run();
         }

src/boost.beast/main.cpp

@@ -1,8 +1,8 @@
+#include "listener.h"
 #include <cstdlib>
 #include <memory>
 #include <thread>
 #include <vector>
-#include "listener.h"
 
 
 int main()
@@ -20,8 +20,7 @@ int main()
     // Run the I/O service on the requested number of threads
     std::vector<std::thread> v;
     v.reserve(threads);
-    for (auto i = 0; i < threads; i++)
-    {
+    for (auto i = 0; i < threads; i++) {
         v.emplace_back([&ioc] { ioc.run(); });
     }
     ioc.run();

src/boost.beast/request.h

@@ -26,20 +26,17 @@ template<class Body, class Allocator, class Send> inline void handleRequest(http
     };
 
     // Make sure we can handle the method
-    switch (req.method())
-    {
+    switch (req.method()) {
     case http::verb::get: {
         // Respond to GET request
         nlohmann::json j = data;
         return send(std::move(createResponse(req, http::status::ok, j)));
     }
     case http::verb::put: {
-        try
-        {
+        try {
             const auto j = nlohmann::json::parse(req.body());
             const data::person d = j;
-            if (d.id > data.size() - 1 || d.id < 0)
-            {
+            if (d.id > data.size() - 1 || d.id < 0) {
                 const nlohmann::json j = R"({"error": "id is larger than data list or negative"})";
                 return send(std::move(createResponse(req, http::status::internal_server_error, j)));
             }
@@ -48,22 +45,17 @@ template<class Body, class Allocator, class Send> inline void handleRequest(http
             temp.address = d.address;
             temp.age = d.age;
             return send(std::move(createResponse(req, http::status::ok, j)));
-        }
-        catch (nlohmann::json::exception &e)
-        {
+        } catch (nlohmann::json::exception &e) {
             return send(std::move(badRequest(e.what())));
         }
     }
     case http::verb::post: {
-        try
-        {
+        try {
             const auto j = nlohmann::json::parse(req.body());
             data.push_back(j);
             data.back().id = static_cast<int>(data.size());
             return send(std::move(createResponse(req, http::status::ok, j)));
-        }
-        catch (nlohmann::json::exception &e)
-        {
+        } catch (nlohmann::json::exception &e) {
             return send(std::move(badRequest(e.what())));
         }
     }

src/boost.beast/session.h

@@ -37,15 +37,9 @@ class Session : public std::enable_shared_from_this<Session>
         boost::ignore_unused(bytes_transferred);
 
         // This means they closed the connection
-        if (ec == http::error::end_of_stream)
-        {
-            return doClose();
-        }
+        if (ec == http::error::end_of_stream) { return doClose(); }
 
-        if (ec)
-        {
-            return fail(ec, "read");
-        }
+        if (ec) { return fail(ec, "read"); }
 
         // Send the response
         handleRequest(std::move(m_req), m_lambda, m_person);
@@ -55,13 +49,9 @@ class Session : public std::enable_shared_from_this<Session>
     {
         boost::ignore_unused(bytes_transferred);
 
-        if (ec)
-        {
-            return fail(ec, "write");
-        }
+        if (ec) { return fail(ec, "write"); }
 
-        if (close)
-        {
+        if (close) {
             // This means we should close the connection, usually because
             // the response indicated the "Connection: close" semantic.
             return doClose();

src/main.cpp

@@ -1,8 +1,8 @@
 #include <functional>
 #include <iostream>
 
-#include <spdlog/spdlog.h>
 #include <docopt/docopt.h>
+#include <spdlog/spdlog.h>
 
 static constexpr auto USAGE =
   R"(Naval Fate.
@@ -24,18 +24,16 @@ static constexpr auto USAGE =
 
 int main(int argc, const char **argv)
 {
-  std::map<std::string, docopt::value> args = docopt::docopt(USAGE,
-    { std::next(argv), std::next(argv, argc) },
-    true,// show help if requested
-    "Naval Fate 2.0");// version string
+    std::map<std::string, docopt::value> args = docopt::docopt(USAGE,
+      { std::next(argv), std::next(argv, argc) },
+      true,// show help if requested
+      "Naval Fate 2.0");// version string
 
-  for (auto const &arg : args) {
-    std::cout << arg.first << arg.second << std::endl;
-  }
+    for (auto const &arg : args) { std::cout << arg.first << arg.second << std::endl; }
 
 
-  //Use the default logger (stdout, multi-threaded, colored)
-  spdlog::info("Hello, {}!", "World");
+    // Use the default logger (stdout, multi-threaded, colored)
+    spdlog::info("Hello, {}!", "World");
 
-  fmt::print("Hello, from {}\n", "{fmt}");
+    fmt::print("Hello, from {}\n", "{fmt}");
 }

src/sml/actions.h

@@ -4,19 +4,19 @@ std::chrono::time_point<std::chrono::steady_clock> startTime;
 
 struct turnOffAction
 {
-  void operator()() { spdlog::info("turned off"); }
+    void operator()() { spdlog::info("turned off"); }
 } turnOffAction;
 
 struct startAction
 {
-  void operator()() { startTime = std::chrono::steady_clock::now(); }
+    void operator()() { startTime = std::chrono::steady_clock::now(); }
 } startAction;
 
 struct stopAction
 {
-  void operator()()
-  {
-    const auto diff = std::chrono::steady_clock::now() - startTime;
-    spdlog::info("Elasped time: {}s", std::chrono::duration_cast<std::chrono::seconds>(diff).count());
-  }
-} stopAction;
+    void operator()()
+    {
+        const auto diff = std::chrono::steady_clock::now() - startTime;
+        spdlog::info("Elasped time: {}s", std::chrono::duration_cast<std::chrono::seconds>(diff).count());
+    }
+} stopAction;

src/sml/logger.h

@@ -2,38 +2,30 @@
 
 struct CustomLogger
 {
-  template<class SM, class TEvent>
-  void log_process_event(const TEvent &)
-  {
-    spdlog::info("[{}][process_event] {}", boost::sml::aux::get_type_name<SM>(), boost::sml::aux::get_type_name<TEvent>());
-  }
+    template<class SM, class TEvent> void log_process_event(const TEvent &)
+    {
+        spdlog::info("[{}][process_event] {}", boost::sml::aux::get_type_name<SM>(), boost::sml::aux::get_type_name<TEvent>());
+    }
 
-  template<class SM, class TGuard, class TEvent>
-  void log_guard(const TGuard &, const TEvent &, bool result)
-  {
-    spdlog::info("[%s][guard] %s %s %s", boost::sml::aux::get_type_name<SM>(), boost::sml::aux::get_type_name<TGuard>(), boost::sml::aux::get_type_name<TEvent>(), (result ? "[OK]" : "[Reject]"));
-  }
+    template<class SM, class TGuard, class TEvent> void log_guard(const TGuard &, const TEvent &, bool result)
+    {
+        spdlog::info("[%s][guard] %s %s %s",
+          boost::sml::aux::get_type_name<SM>(),
+          boost::sml::aux::get_type_name<TGuard>(),
+          boost::sml::aux::get_type_name<TEvent>(),
+          (result ? "[OK]" : "[Reject]"));
+    }
 
-  template<class SM, class TAction, class TEvent>
-  void log_action(const TAction &, const TEvent &)
-  {
-    spdlog::info("[{}][action] {} {}", boost::sml::aux::get_type_name<SM>(), boost::sml::aux::get_type_name<TAction>(), boost::sml::aux::get_type_name<TEvent>());
-  }
+    template<class SM, class TAction, class TEvent> void log_action(const TAction &, const TEvent &)
+    {
+        spdlog::info("[{}][action] {} {}", boost::sml::aux::get_type_name<SM>(), boost::sml::aux::get_type_name<TAction>(), boost::sml::aux::get_type_name<TEvent>());
+    }
 
-  template<class SM, class TSrcState, class TDstState>
-  void log_state_change(const TSrcState &src, const TDstState &dst)
-  {
-    spdlog::info("[{}][transition] {} -> {}", boost::sml::aux::get_type_name<SM>(), src.c_str(), dst.c_str());
-  }
+    template<class SM, class TSrcState, class TDstState> void log_state_change(const TSrcState &src, const TDstState &dst)
+    {
+        spdlog::info("[{}][transition] {} -> {}", boost::sml::aux::get_type_name<SM>(), src.c_str(), dst.c_str());
+    }
 
-  template<class SM, class _, class TEvent>
-  void log_process_event(const boost::sml::back::on_entry<_, TEvent> &)
-  {
-    spdlog::info("on_entry");
-  }
-  template<class SM, class _, class TEvent>
-  void log_process_event(const boost::sml::back::on_exit<_, TEvent> &)
-  {
-    spdlog::info("on_exit");
-  }
-};
+    template<class SM, class _, class TEvent> void log_process_event(const boost::sml::back::on_entry<_, TEvent> &) { spdlog::info("on_entry"); }
+    template<class SM, class _, class TEvent> void log_process_event(const boost::sml::back::on_exit<_, TEvent> &) { spdlog::info("on_exit"); }
+};