Adds linters, code formatters for both js and c++ and adds prepush hook (#178)

.clang-format

@@ -0,0 +1,8 @@
+BasedOnStyle: Google
+IndentWidth: 2
+---
+Language: Cpp
+
+PointerAlignment: Left
+AlwaysBreakAfterReturnType: None
+SortIncludes: true

.eslintrc.js

@@ -0,0 +1,28 @@
+module.exports = {
+  extends: [
+    "plugin:prettier/recommended" // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
+  ],
+  parserOptions: {
+    ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
+    sourceType: "module" // Allows for the use of imports
+  },
+  overrides: [
+    {
+      files: ["*.ts", "*.tsx"],
+      parser: "@typescript-eslint/parser", // Specifies the ESLint parser
+      extends: [
+        "plugin:@typescript-eslint/recommended", // Uses the recommended rules from the @typescript-eslint/eslint-plugin
+        "prettier/@typescript-eslint", // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
+        "plugin:prettier/recommended" // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
+      ],
+      parserOptions: {
+        ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
+        sourceType: "module" // Allows for the use of imports
+      },
+      rules: {
+        "@typescript-eslint/camelcase": 0,
+        "@typescript-eslint/no-var-requires": 0
+      }
+    }
+  ]
+};

.prettierrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+    semi: true,
+    trailingComma: 'all',
+    singleQuote: true,
+    printWidth: 120,
+    tabWidth: 4,
+};

package.json

@@ -20,7 +20,9 @@
         "postinstall": "npm run build:addon",
         "build": "tsc && npm run build:addon",
         "build:addon": "cross-env CMAKE_BUILD_PARALLEL_LEVEL=8 cmake-js build",
-    "test": "qode ./node_modules/.bin/jest"
+        "test": "qode ./node_modules/.bin/jest",
+        "lint:cpp": "clang-format -i --glob=src/cpp/**/*.[h,c]*",
+        "lint:ts": "tsc --noEmit && eslint './src/**/*.{ts,tsx}' --fix"
     },
     "dependencies": {
         "@nodegui/qode": "^1.0.5",
@@ -34,10 +36,22 @@
         "@types/bindings": "^1.3.0",
         "@types/jest": "^24.0.18",
         "@types/node": "^12.0.2",
+        "@typescript-eslint/eslint-plugin": "^2.6.1",
+        "@typescript-eslint/parser": "^2.6.1",
+        "clang-format": "^1.3.0",
+        "eslint": "^6.6.0",
+        "eslint-config-prettier": "^6.5.0",
+        "eslint-plugin-prettier": "^3.1.1",
+        "husky": "^3.0.9",
         "jest": "^24.9.0",
-    "prettier": "^1.17.1",
+        "prettier": "^1.18.2",
         "serve": "^11.1.0",
         "ts-jest": "^24.1.0",
         "typescript": "^3.6.3"
+    },
+    "husky": {
+        "hooks": {
+            "pre-push": "npm run lint:ts && npm run lint:cpp && npm run test"
+        }
     }
 }

src/cpp/include/deps/spdlog/async.h

@@ -17,13 +17,13 @@
 // This is because each message in the queue holds a shared_ptr to the
 // originating logger.
 
+#include <memory>
+#include <mutex>
+
 #include "spdlog/async_logger.h"
 #include "spdlog/details/registry.h"
 #include "spdlog/details/thread_pool.h"
 
-#include <memory>
-#include <mutex>
-
 namespace spdlog {
 
 namespace details {
@@ -34,54 +34,55 @@ static const size_t default_async_q_size = 8192;
 // if a global thread pool doesn't already exist, create it with default queue
 // size of 8192 items and single thread.
 template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-struct async_factory_impl
+struct async_factory_impl {
-{
   template <typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
+  static std::shared_ptr<async_logger> create(std::string logger_name,
-    {
+                                              SinkArgs &&... args) {
     auto &registry_inst = details::registry::instance();
 
     // create global thread pool if not already exists..
     std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
     auto tp = registry_inst.get_tp();
-        if (tp == nullptr)
+    if (tp == nullptr) {
-        {
+      tp = std::make_shared<details::thread_pool>(details::default_async_q_size,
-            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1);
+                                                  1);
       registry_inst.set_tp(tp);
     }
 
     auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+    auto new_logger = std::make_shared<async_logger>(
+        std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
     registry_inst.initialize_logger(new_logger);
     return new_logger;
   }
 };
 
 using async_factory = async_factory_impl<async_overflow_policy::block>;
-using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
+using async_factory_nonblock =
+    async_factory_impl<async_overflow_policy::overrun_oldest>;
 
 template <typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
-{
+                                                    SinkArgs &&... sink_args) {
-    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+  return async_factory::create<Sink>(std::move(logger_name),
+                                     std::forward<SinkArgs>(sink_args)...);
 }
 
 template <typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create_async_nb(
-{
+    std::string logger_name, SinkArgs &&... sink_args) {
-    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+  return async_factory_nonblock::create<Sink>(
+      std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
-inline void init_thread_pool(size_t q_size, size_t thread_count)
+inline void init_thread_pool(size_t q_size, size_t thread_count) {
-{
   auto tp = std::make_shared<details::thread_pool>(q_size, thread_count);
   details::registry::instance().set_tp(std::move(tp));
 }
 
 // get the global thread pool.
-inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
-{
   return details::registry::instance().get_tp();
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/async_logger.h

@@ -19,18 +19,17 @@
 // Upon destruction, logs all remaining messages in the queue before
 // destructing..
 
-#include "spdlog/common.h"
-#include "spdlog/logger.h"
-
 #include <chrono>
 #include <memory>
 #include <string>
 
+#include "spdlog/common.h"
+#include "spdlog/logger.h"
+
 namespace spdlog {
 
 // Async overflow policy - block by default.
-enum class async_overflow_policy
+enum class async_overflow_policy {
-{
   block,          // Block until message can be enqueued
   overrun_oldest  // Discard oldest message in the queue if full when trying to
                   // add new item.
@@ -40,19 +39,25 @@ namespace details {
 class thread_pool;
 }
 
-class async_logger final : public std::enable_shared_from_this<async_logger>, public logger
+class async_logger final : public std::enable_shared_from_this<async_logger>,
-{
+                           public logger {
   friend class details::thread_pool;
 
  public:
   template <typename It>
-    async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
+  async_logger(
+      std::string logger_name, It begin, It end,
+      std::weak_ptr<details::thread_pool> tp,
       async_overflow_policy overflow_policy = async_overflow_policy::block);
 
-    async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
+  async_logger(
+      std::string logger_name, sinks_init_list sinks_list,
+      std::weak_ptr<details::thread_pool> tp,
       async_overflow_policy overflow_policy = async_overflow_policy::block);
 
-    async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
+  async_logger(
+      std::string logger_name, sink_ptr single_sink,
+      std::weak_ptr<details::thread_pool> tp,
       async_overflow_policy overflow_policy = async_overflow_policy::block);
 
   std::shared_ptr<logger> clone(std::string new_name) override;

src/cpp/include/deps/spdlog/common.h

@@ -5,26 +5,25 @@
 
 #pragma once
 
-#include "spdlog/tweakme.h"
-
 #include <atomic>
 #include <chrono>
+#include <cstring>
 #include <functional>
 #include <initializer_list>
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <cstring>
 #include <type_traits>
 #include <unordered_map>
 
+#include "spdlog/tweakme.h"
+
 #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 #include <codecvt>
 #include <locale>
 #endif
 
 #include "spdlog/details/null_mutex.h"
-
 #include "spdlog/fmt/fmt.h"
 
 // visual studio upto 2013 does not support noexcept nor constexpr
@@ -108,8 +107,7 @@ using level_t = std::atomic<int>;
 
 // Log level enum
 namespace level {
-enum level_enum
+enum level_enum {
-{
   trace = SPDLOG_LEVEL_TRACE,
   debug = SPDLOG_LEVEL_DEBUG,
   info = SPDLOG_LEVEL_INFO,
@@ -121,31 +119,26 @@ enum level_enum
 
 #if !defined(SPDLOG_LEVEL_NAMES)
 #define SPDLOG_LEVEL_NAMES \
-    {                                                                                                                                      \
+  { "trace", "debug", "info", "warning", "error", "critical", "off" }
-        "trace", "debug", "info", "warning", "error", "critical", "off"                                                                    \
-    }
 #endif
 
 static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES;
 static const char *short_level_names[]{"T", "D", "I", "W", "E", "C", "O"};
 
-inline string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+inline string_view_t &to_string_view(spdlog::level::level_enum l)
-{
+    SPDLOG_NOEXCEPT {
   return level_string_views[l];
 }
 
-inline const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT
+inline const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT {
-{
   return short_level_names[l];
 }
 
-inline spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT
+inline spdlog::level::level_enum from_str(const std::string &name)
-{
+    SPDLOG_NOEXCEPT {
   int level = 0;
-    for (const auto &level_str : level_string_views)
+  for (const auto &level_str : level_string_views) {
-    {
+    if (level_str == name) {
-        if (level_str == name)
-        {
       return static_cast<level::level_enum>(level);
     }
     level++;
@@ -160,8 +153,7 @@ using level_hasher = std::hash<int>;
 // Pattern time - specific time getting to use for pattern_formatter.
 // local time by default
 //
-enum class pattern_time_type
+enum class pattern_time_type {
-{
   local,  // log localtime
   utc     // log utc
 };
@@ -169,25 +161,17 @@ enum class pattern_time_type
 //
 // Log exception
 //
-class spdlog_ex : public std::exception
+class spdlog_ex : public std::exception {
-{
  public:
-    explicit spdlog_ex(std::string msg)
+  explicit spdlog_ex(std::string msg) : msg_(std::move(msg)) {}
-        : msg_(std::move(msg))
-    {
-    }
 
-    spdlog_ex(const std::string &msg, int last_errno)
+  spdlog_ex(const std::string &msg, int last_errno) {
-    {
     fmt::memory_buffer outbuf;
     fmt::format_system_error(outbuf, last_errno, msg);
     msg_ = fmt::to_string(outbuf);
   }
 
-    const char *what() const SPDLOG_NOEXCEPT override
+  const char *what() const SPDLOG_NOEXCEPT override { return msg_.c_str(); }
-    {
-        return msg_.c_str();
-    }
 
  private:
   std::string msg_;
@@ -202,25 +186,15 @@ using filename_t = std::wstring;
 using filename_t = std::string;
 #endif
 
-struct source_loc
+struct source_loc {
-{
+  SPDLOG_CONSTEXPR source_loc() : filename{""}, line{0}, funcname{""} {}
-    SPDLOG_CONSTEXPR source_loc()
+  SPDLOG_CONSTEXPR source_loc(const char *filename, int line,
-        : filename{""}
+                              const char *funcname)
-        , line{0}
+      : filename{filename},
-        , funcname{""}
+        line{static_cast<uint32_t>(line)},
-    {
+        funcname{funcname} {}
-    }
-    SPDLOG_CONSTEXPR source_loc(const char *filename, int line, const char *funcname)
-        : filename{filename}
-        , line{static_cast<uint32_t>(line)}
-        , funcname{funcname}
-    {
-    }
 
-    SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT
+  SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line == 0; }
-    {
-        return line == 0;
-    }
   const char *filename;
   uint32_t line;
   const char *funcname;
@@ -233,8 +207,7 @@ namespace details {
 using std::make_unique;
 #else
 template <typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&... args)
+std::unique_ptr<T> make_unique(Args &&... args) {
-{
   static_assert(!std::is_array<T>::value, "arrays not supported");
   return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }

src/cpp/include/deps/spdlog/details/async_logger_impl.h

@@ -8,58 +8,52 @@
 // async logger implementation
 // uses a thread pool to perform the actual logging
 
-#include "spdlog/details/thread_pool.h"
-
 #include <chrono>
 #include <memory>
 #include <string>
 
+#include "spdlog/details/thread_pool.h"
+
 template <typename It>
 inline spdlog::async_logger::async_logger(
-    std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    std::string logger_name, It begin, It end,
-    : logger(std::move(logger_name), begin, end)
+    std::weak_ptr<details::thread_pool> tp,
-    , thread_pool_(std::move(tp))
+    async_overflow_policy overflow_policy)
-    , overflow_policy_(overflow_policy)
+    : logger(std::move(logger_name), begin, end),
-{
+      thread_pool_(std::move(tp)),
-}
+      overflow_policy_(overflow_policy) {}
 
 inline spdlog::async_logger::async_logger(
-    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    std::string logger_name, sinks_init_list sinks_list,
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+    std::weak_ptr<details::thread_pool> tp,
-{
+    async_overflow_policy overflow_policy)
-}
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(),
+                   std::move(tp), overflow_policy) {}
 
 inline spdlog::async_logger::async_logger(
-    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
+    std::string logger_name, sink_ptr single_sink,
-    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+    std::weak_ptr<details::thread_pool> tp,
-{
+    async_overflow_policy overflow_policy)
-}
+    : async_logger(std::move(logger_name), {std::move(single_sink)},
+                   std::move(tp), overflow_policy) {}
 
 // send the log message to the thread pool
-inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
+inline void spdlog::async_logger::sink_it_(details::log_msg &msg) {
-{
 #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
   incr_msg_counter_(msg);
 #endif
-    if (auto pool_ptr = thread_pool_.lock())
+  if (auto pool_ptr = thread_pool_.lock()) {
-    {
     pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
-    }
+  } else {
-    else
-    {
     throw spdlog_ex("async log: thread pool doesn't exist anymore");
   }
 }
 
 // send flush request to the thread pool
-inline void spdlog::async_logger::flush_()
+inline void spdlog::async_logger::flush_() {
-{
+  if (auto pool_ptr = thread_pool_.lock()) {
-    if (auto pool_ptr = thread_pool_.lock())
-    {
     pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-    }
+  } else {
-    else
-    {
     throw spdlog_ex("async flush: thread pool doesn't exist anymore");
   }
 }
@@ -67,41 +61,36 @@ inline void spdlog::async_logger::flush_()
 //
 // backend functions - called from the thread pool to do the actual job
 //
-inline void spdlog::async_logger::backend_log_(const details::log_msg &incoming_log_msg)
+inline void spdlog::async_logger::backend_log_(
-{
+    const details::log_msg &incoming_log_msg) {
-    try
+  try {
-    {
+    for (auto &s : sinks_) {
-        for (auto &s : sinks_)
+      if (s->should_log(incoming_log_msg.level)) {
-        {
-            if (s->should_log(incoming_log_msg.level))
-            {
         s->log(incoming_log_msg);
       }
     }
   }
   SPDLOG_CATCH_AND_HANDLE
 
-    if (should_flush_(incoming_log_msg))
+  if (should_flush_(incoming_log_msg)) {
-    {
     backend_flush_();
   }
 }
 
-inline void spdlog::async_logger::backend_flush_()
+inline void spdlog::async_logger::backend_flush_() {
-{
+  try {
-    try
+    for (auto &sink : sinks_) {
-    {
-        for (auto &sink : sinks_)
-        {
       sink->flush();
     }
   }
   SPDLOG_CATCH_AND_HANDLE
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(
-{
+    std::string new_name) {
-    auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_);
+  auto cloned = std::make_shared<spdlog::async_logger>(
+      std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_,
+      overflow_policy_);
 
   cloned->set_level(this->level());
   cloned->flush_on(this->flush_level());

src/cpp/include/deps/spdlog/details/circular_q.h

@@ -11,20 +11,17 @@
 namespace spdlog {
 namespace details {
 template <typename T>
-class circular_q
+class circular_q {
-{
  public:
   using item_type = T;
 
   explicit circular_q(size_t max_items)
       : max_items_(max_items + 1)  // one item is reserved as marker for full q
-        , v_(max_items_)
+        ,
-    {
+        v_(max_items_) {}
-    }
 
   // push back, overrun (oldest) item if no room left
-    void push_back(T &&item)
+  void push_back(T &&item) {
-    {
     v_[tail_] = std::move(item);
     tail_ = (tail_ + 1) % max_items_;
 
@@ -37,27 +34,19 @@ public:
 
   // Pop item from front.
   // If there are no elements in the container, the behavior is undefined.
-    void pop_front(T &popped_item)
+  void pop_front(T &popped_item) {
-    {
     popped_item = std::move(v_[head_]);
     head_ = (head_ + 1) % max_items_;
   }
 
-    bool empty()
+  bool empty() { return tail_ == head_; }
-    {
-        return tail_ == head_;
-    }
 
-    bool full()
+  bool full() {
-    {
     // head is ahead of the tail by 1
     return ((tail_ + 1) % max_items_) == head_;
   }
 
-    size_t overrun_counter() const
+  size_t overrun_counter() const { return overrun_counter_; }
-    {
-        return overrun_counter_;
-    }
 
  private:
   size_t max_items_;

src/cpp/include/deps/spdlog/details/console_globals.h

@@ -4,10 +4,11 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
-#include "spdlog/details/null_mutex.h"
 #include <cstdio>
 #include <mutex>
 
+#include "spdlog/details/null_mutex.h"
+
 #ifdef _WIN32
 
 #ifndef NOMINMAX
@@ -23,49 +24,31 @@
 
 namespace spdlog {
 namespace details {
-struct console_stdout
+struct console_stdout {
-{
+  static std::FILE *stream() { return stdout; }
-    static std::FILE *stream()
-    {
-        return stdout;
-    }
 #ifdef _WIN32
-    static HANDLE handle()
+  static HANDLE handle() { return ::GetStdHandle(STD_OUTPUT_HANDLE); }
-    {
-        return ::GetStdHandle(STD_OUTPUT_HANDLE);
-    }
 #endif
 };
 
-struct console_stderr
+struct console_stderr {
-{
+  static std::FILE *stream() { return stderr; }
-    static std::FILE *stream()
-    {
-        return stderr;
-    }
 #ifdef _WIN32
-    static HANDLE handle()
+  static HANDLE handle() { return ::GetStdHandle(STD_ERROR_HANDLE); }
-    {
-        return ::GetStdHandle(STD_ERROR_HANDLE);
-    }
 #endif
 };
 
-struct console_mutex
+struct console_mutex {
-{
   using mutex_t = std::mutex;
-    static mutex_t &mutex()
+  static mutex_t &mutex() {
-    {
     static mutex_t s_mutex;
     return s_mutex;
   }
 };
 
-struct console_nullmutex
+struct console_nullmutex {
-{
   using mutex_t = null_mutex;
-    static mutex_t &mutex()
+  static mutex_t &mutex() {
-    {
     static mutex_t s_mutex;
     return s_mutex;
   }

src/cpp/include/deps/spdlog/details/file_helper.h

@@ -6,11 +6,8 @@
 #pragma once
 
 // Helper class for file sinks.
-// When failing to open a file, retry several times(5) with a delay interval(10 ms).
+// When failing to open a file, retry several times(5) with a delay interval(10
-// Throw spdlog_ex exception on errors.
+// ms). Throw spdlog_ex exception on errors.
-
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
 
 #include <cerrno>
 #include <chrono>
@@ -19,12 +16,13 @@
 #include <thread>
 #include <tuple>
 
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/os.h"
+
 namespace spdlog {
 namespace details {
 
-class file_helper
+class file_helper {
-{
-
  public:
   const int open_tries = 5;
   const int open_interval = 10;
@@ -34,78 +32,61 @@ public:
   file_helper(const file_helper &) = delete;
   file_helper &operator=(const file_helper &) = delete;
 
-    ~file_helper()
+  ~file_helper() { close(); }
-    {
-        close();
-    }
 
-    void open(const filename_t &fname, bool truncate = false)
+  void open(const filename_t &fname, bool truncate = false) {
-    {
     close();
     auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
     _filename = fname;
-        for (int tries = 0; tries < open_tries; ++tries)
+    for (int tries = 0; tries < open_tries; ++tries) {
-        {
+      if (!os::fopen_s(&fd_, fname, mode)) {
-            if (!os::fopen_s(&fd_, fname, mode))
-            {
         return;
       }
 
       details::os::sleep_for_millis(open_interval);
     }
 
-        throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
+    throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) +
+                        " for writing",
+                    errno);
   }
 
-    void reopen(bool truncate)
+  void reopen(bool truncate) {
-    {
+    if (_filename.empty()) {
-        if (_filename.empty())
-        {
       throw spdlog_ex("Failed re opening file - was not opened before");
     }
     open(_filename, truncate);
   }
 
-    void flush()
+  void flush() { std::fflush(fd_); }
-    {
-        std::fflush(fd_);
-    }
 
-    void close()
+  void close() {
-    {
+    if (fd_ != nullptr) {
-        if (fd_ != nullptr)
-        {
       std::fclose(fd_);
       fd_ = nullptr;
     }
   }
 
-    void write(const fmt::memory_buffer &buf)
+  void write(const fmt::memory_buffer &buf) {
-    {
     size_t msg_size = buf.size();
     auto data = buf.data();
-        if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
-        {
+      throw spdlog_ex(
-            throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
+          "Failed writing to file " + os::filename_to_str(_filename), errno);
     }
   }
 
-    size_t size() const
+  size_t size() const {
-    {
+    if (fd_ == nullptr) {
-        if (fd_ == nullptr)
+      throw spdlog_ex("Cannot use size() on closed file " +
-        {
+                      os::filename_to_str(_filename));
-            throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
     }
     return os::filesize(fd_);
   }
 
-    const filename_t &filename() const
+  const filename_t &filename() const { return _filename; }
-    {
-        return _filename;
-    }
 
-    static bool file_exists(const filename_t &fname)
+  static bool file_exists(const filename_t &fname) {
-    {
     return os::file_exists(fname);
   }
 
@@ -122,21 +103,20 @@ public:
   // ".mylog" => (".mylog". "")
   // "my_folder/.mylog" => ("my_folder/.mylog", "")
   // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
-    static std::tuple<filename_t, filename_t> split_by_extension(const spdlog::filename_t &fname)
+  static std::tuple<filename_t, filename_t> split_by_extension(
-    {
+      const spdlog::filename_t &fname) {
     auto ext_index = fname.rfind('.');
 
     // no valid extension found - return whole path and empty string as
     // extension
-        if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    if (ext_index == filename_t::npos || ext_index == 0 ||
-        {
+        ext_index == fname.size() - 1) {
       return std::make_tuple(fname, spdlog::filename_t());
     }
 
     // treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
     auto folder_index = fname.rfind(details::os::folder_sep);
-        if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1) {
-        {
       return std::make_tuple(fname, spdlog::filename_t());
     }
 

src/cpp/include/deps/spdlog/details/fmt_helper.h

@@ -6,6 +6,7 @@
 
 #include <chrono>
 #include <type_traits>
+
 #include "spdlog/fmt/fmt.h"
 
 // Some fmt helpers to efficiently format and pad ints and strings
@@ -14,72 +15,66 @@ namespace details {
 namespace fmt_helper {
 
 template <size_t Buffer_Size>
-inline spdlog::string_view_t to_string_view(const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT
+inline spdlog::string_view_t to_string_view(
-{
+    const fmt::basic_memory_buffer<char, Buffer_Size> &buf) SPDLOG_NOEXCEPT {
   return spdlog::string_view_t(buf.data(), buf.size());
 }
 
 template <size_t Buffer_Size1, size_t Buffer_Size2>
-inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest)
+inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf,
-{
+                       fmt::basic_memory_buffer<char, Buffer_Size2> &dest) {
   auto *buf_ptr = buf.data();
   dest.append(buf_ptr, buf_ptr + buf.size());
 }
 
 template <size_t Buffer_Size>
-inline void append_string_view(spdlog::string_view_t view, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void append_string_view(
-{
+    spdlog::string_view_t view,
+    fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
   auto *buf_ptr = view.data();
-    if (buf_ptr != nullptr)
+  if (buf_ptr != nullptr) {
-    {
     dest.append(buf_ptr, buf_ptr + view.size());
   }
 }
 
 template <typename T, size_t Buffer_Size>
-inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
-{
   fmt::format_int i(n);
   dest.append(i.data(), i.data() + i.size());
 }
 
 template <typename T>
-inline unsigned count_digits(T n)
+inline unsigned count_digits(T n) {
-{
+  using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)),
-    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+                                               uint64_t, uint32_t>::type;
-    return static_cast<unsigned>(fmt::internal::count_digits(static_cast<count_type>(n)));
+  return static_cast<unsigned>(
+      fmt::internal::count_digits(static_cast<count_type>(n)));
 }
 
 template <size_t Buffer_Size>
-inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
-{
+  if (n > 99) {
-    if (n > 99)
-    {
     append_int(n, dest);
-    }
+  } else if (n > 9)  // 10-99
-    else if (n > 9) // 10-99
   {
     dest.push_back(static_cast<char>('0' + n / 10));
     dest.push_back(static_cast<char>('0' + n % 10));
-    }
+  } else if (n >= 0)  // 0-9
-    else if (n >= 0) // 0-9
   {
     dest.push_back('0');
     dest.push_back(static_cast<char>('0' + n));
-    }
+  } else  // negatives (unlikely, but just in case, let fmt deal with it)
-    else // negatives (unlikely, but just in case, let fmt deal with it)
   {
     fmt::format_to(dest, "{:02}", n);
   }
 }
 
 template <typename T, size_t Buffer_Size>
-inline void pad_uint(T n, unsigned int width, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad_uint(T n, unsigned int width,
-{
+                     fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
   static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
   auto digits = count_digits(n);
-    if (width > digits)
+  if (width > digits) {
-    {
     const char *zeroes = "0000000000000000000";
     dest.append(zeroes, zeroes + width - digits);
   }
@@ -87,20 +82,17 @@ inline void pad_uint(T n, unsigned int width, fmt::basic_memory_buffer<char, Buf
 }
 
 template <typename T, size_t Buffer_Size>
-inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad3(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
-{
   pad_uint(n, 3, dest);
 }
 
 template <typename T, size_t Buffer_Size>
-inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad6(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
-{
   pad_uint(n, 6, dest);
 }
 
 template <typename T, size_t Buffer_Size>
-inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
+inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) {
-{
   pad_uint(n, 9, dest);
 }
 
@@ -108,8 +100,7 @@ inline void pad9(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 // e.g.
 // fraction<std::milliseconds>(tp) -> will return the millis part of the second
 template <typename ToDuration>
-inline ToDuration time_fraction(const log_clock::time_point &tp)
+inline ToDuration time_fraction(const log_clock::time_point &tp) {
-{
   using std::chrono::duration_cast;
   using std::chrono::seconds;
   auto duration = tp.time_since_epoch();

src/cpp/include/deps/spdlog/details/log_msg.h

@@ -5,36 +5,36 @@
 
 #pragma once
 
-#include "spdlog/common.h"
-#include "spdlog/details/os.h"
-
 #include <string>
 #include <utility>
 
+#include "spdlog/common.h"
+#include "spdlog/details/os.h"
+
 namespace spdlog {
 namespace details {
-struct log_msg
+struct log_msg {
-{
+  log_msg(source_loc loc, const std::string *loggers_name,
-
+          level::level_enum lvl, string_view_t view)
-    log_msg(source_loc loc, const std::string *loggers_name, level::level_enum lvl, string_view_t view)
+      : logger_name(loggers_name),
-        : logger_name(loggers_name)
+        level(lvl)
-        , level(lvl)
 #ifndef SPDLOG_NO_DATETIME
-        , time(os::now())
+        ,
+        time(os::now())
 #endif
 
 #ifndef SPDLOG_NO_THREAD_ID
-        , thread_id(os::thread_id())
+        ,
+        thread_id(os::thread_id())
 #endif
-        , source(loc)
+        ,
-        , payload(view)
+        source(loc),
-    {
+        payload(view) {
   }
 
-    log_msg(const std::string *loggers_name, level::level_enum lvl, string_view_t view)
+  log_msg(const std::string *loggers_name, level::level_enum lvl,
-        : log_msg(source_loc{}, loggers_name, lvl, view)
+          string_view_t view)
-    {
+      : log_msg(source_loc{}, loggers_name, lvl, view) {}
-    }
 
   log_msg(const log_msg &other) = default;
 

src/cpp/include/deps/spdlog/details/logger_impl.h

@@ -5,18 +5,16 @@
 
 #pragma once
 
-#include "spdlog/details/fmt_helper.h"
-
 #include <memory>
 #include <string>
 
+#include "spdlog/details/fmt_helper.h"
+
 #define SPDLOG_CATCH_AND_HANDLE                  \
-    catch (const std::exception &ex)                                                                                                       \
+  catch (const std::exception &ex) {             \
-    {                                                                                                                                      \
     err_handler_(ex.what());                     \
   }                                              \
-    catch (...)                                                                                                                            \
+  catch (...) {                                  \
-    {                                                                                                                                      \
     err_handler_("Unknown exception in logger"); \
   }
 
@@ -24,49 +22,42 @@
 // all other ctors will call this one
 template <typename It>
 inline spdlog::logger::logger(std::string logger_name, It begin, It end)
-    : name_(std::move(logger_name))
+    : name_(std::move(logger_name)), sinks_(begin, end) {}
-    , sinks_(begin, end)
-{
-}
 
 // ctor with sinks as init list
-inline spdlog::logger::logger(std::string logger_name, sinks_init_list sinks_list)
+inline spdlog::logger::logger(std::string logger_name,
-    : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end())
+                              sinks_init_list sinks_list)
-{
+    : logger(std::move(logger_name), sinks_list.begin(), sinks_list.end()) {}
-}
 
 // ctor with single sink
-inline spdlog::logger::logger(std::string logger_name, spdlog::sink_ptr single_sink)
+inline spdlog::logger::logger(std::string logger_name,
-    : logger(std::move(logger_name), {std::move(single_sink)})
+                              spdlog::sink_ptr single_sink)
-{
+    : logger(std::move(logger_name), {std::move(single_sink)}) {}
-}
 
 inline spdlog::logger::~logger() = default;
 
-inline void spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter> f)
+inline void spdlog::logger::set_formatter(
-{
+    std::unique_ptr<spdlog::formatter> f) {
-    for (auto &sink : sinks_)
+  for (auto &sink : sinks_) {
-    {
     sink->set_formatter(f->clone());
   }
 }
 
-inline void spdlog::logger::set_pattern(std::string pattern, pattern_time_type time_type)
+inline void spdlog::logger::set_pattern(std::string pattern,
-{
+                                        pattern_time_type time_type) {
-    auto new_formatter = details::make_unique<spdlog::pattern_formatter>(std::move(pattern), time_type);
+  auto new_formatter = details::make_unique<spdlog::pattern_formatter>(
+      std::move(pattern), time_type);
   set_formatter(std::move(new_formatter));
 }
 
 template <typename... Args>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
+inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
-{
+                                const char *fmt, const Args &... args) {
-    if (!should_log(lvl))
+  if (!should_log(lvl)) {
-    {
     return;
   }
 
-    try
+  try {
-    {
     using details::fmt_helper::to_string_view;
     fmt::memory_buffer buf;
     fmt::format_to(buf, fmt, args...);
@@ -77,61 +68,59 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
 }
 
 template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Args &... args)
+inline void spdlog::logger::log(level::level_enum lvl, const char *fmt,
-{
+                                const Args &... args) {
   log(source_loc{}, lvl, fmt, args...);
 }
 
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *msg)
+inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
-{
+                                const char *msg) {
-    if (!should_log(lvl))
+  if (!should_log(lvl)) {
-    {
     return;
   }
 
-    try
+  try {
-    {
     details::log_msg log_msg(source, &name_, lvl, spdlog::string_view_t(msg));
     sink_it_(log_msg);
   }
   SPDLOG_CATCH_AND_HANDLE
 }
 
-inline void spdlog::logger::log(level::level_enum lvl, const char *msg)
+inline void spdlog::logger::log(level::level_enum lvl, const char *msg) {
-{
   log(source_loc{}, lvl, msg);
 }
 
-template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+template <class T,
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
+          typename std::enable_if<
-{
+              std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-    if (!should_log(lvl))
+inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
-    {
+                                const T &msg) {
+  if (!should_log(lvl)) {
     return;
   }
-    try
+  try {
-    {
     details::log_msg log_msg(source, &name_, lvl, msg);
     sink_it_(log_msg);
   }
   SPDLOG_CATCH_AND_HANDLE
 }
 
-template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+template <class T,
-inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
+          typename std::enable_if<
-{
+              std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+inline void spdlog::logger::log(level::level_enum lvl, const T &msg) {
   log(source_loc{}, lvl, msg);
 }
 
-template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+template <class T,
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const T &msg)
+          typename std::enable_if<
-{
+              !std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
-    if (!should_log(lvl))
+inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
-    {
+                                const T &msg) {
+  if (!should_log(lvl)) {
     return;
   }
-    try
+  try {
-    {
     using details::fmt_helper::to_string_view;
     fmt::memory_buffer buf;
     fmt::format_to(buf, "{}", msg);
@@ -141,117 +130,103 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
   SPDLOG_CATCH_AND_HANDLE
 }
 
-template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+template <class T,
-inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
+          typename std::enable_if<
-{
+              !std::is_convertible<T, spdlog::string_view_t>::value, T>::type *>
+inline void spdlog::logger::log(level::level_enum lvl, const T &msg) {
   log(source_loc{}, lvl, msg);
 }
 
 template <typename... Args>
-inline void spdlog::logger::trace(const char *fmt, const Args &... args)
+inline void spdlog::logger::trace(const char *fmt, const Args &... args) {
-{
   log(level::trace, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::debug(const char *fmt, const Args &... args)
+inline void spdlog::logger::debug(const char *fmt, const Args &... args) {
-{
   log(level::debug, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::info(const char *fmt, const Args &... args)
+inline void spdlog::logger::info(const char *fmt, const Args &... args) {
-{
   log(level::info, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::warn(const char *fmt, const Args &... args)
+inline void spdlog::logger::warn(const char *fmt, const Args &... args) {
-{
   log(level::warn, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::error(const char *fmt, const Args &... args)
+inline void spdlog::logger::error(const char *fmt, const Args &... args) {
-{
   log(level::err, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::critical(const char *fmt, const Args &... args)
+inline void spdlog::logger::critical(const char *fmt, const Args &... args) {
-{
   log(level::critical, fmt, args...);
 }
 
 template <typename T>
-inline void spdlog::logger::trace(const T &msg)
+inline void spdlog::logger::trace(const T &msg) {
-{
   log(level::trace, msg);
 }
 
 template <typename T>
-inline void spdlog::logger::debug(const T &msg)
+inline void spdlog::logger::debug(const T &msg) {
-{
   log(level::debug, msg);
 }
 
 template <typename T>
-inline void spdlog::logger::info(const T &msg)
+inline void spdlog::logger::info(const T &msg) {
-{
   log(level::info, msg);
 }
 
 template <typename T>
-inline void spdlog::logger::warn(const T &msg)
+inline void spdlog::logger::warn(const T &msg) {
-{
   log(level::warn, msg);
 }
 
 template <typename T>
-inline void spdlog::logger::error(const T &msg)
+inline void spdlog::logger::error(const T &msg) {
-{
   log(level::err, msg);
 }
 
 template <typename T>
-inline void spdlog::logger::critical(const T &msg)
+inline void spdlog::logger::critical(const T &msg) {
-{
   log(level::critical, msg);
 }
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
-inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf, fmt::memory_buffer &target)
+inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf,
-{
+                            fmt::memory_buffer &target) {
   int wbuf_size = static_cast<int>(wbuf.size());
-    if (wbuf_size == 0)
+  if (wbuf_size == 0) {
-    {
     return;
   }
 
-    auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, NULL, 0, NULL, NULL);
+  auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size,
+                                           NULL, 0, NULL, NULL);
 
-    if (result_size > 0)
+  if (result_size > 0) {
-    {
     target.resize(result_size);
-        ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL);
+    ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0],
-    }
+                          result_size, NULL, NULL);
-    else
+  } else {
-    {
+    throw spdlog::spdlog_ex(fmt::format(
-        throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+        "WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
   }
 }
 
 template <typename... Args>
-inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::log(source_loc source, level::level_enum lvl,
-{
+                                const wchar_t *fmt, const Args &... args) {
-    if (!should_log(lvl))
+  if (!should_log(lvl)) {
-    {
     return;
   }
 
-    try
+  try {
-    {
     // format to wmemory_buffer and convert to utf8
     using details::fmt_helper::to_string_view;
     fmt::wmemory_buffer wbuf;
@@ -265,44 +240,38 @@ inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const
 }
 
 template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt,
-{
+                                const Args &... args) {
   log(source_loc{}, lvl, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::trace(const wchar_t *fmt, const Args &... args) {
-{
   log(level::trace, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::debug(const wchar_t *fmt, const Args &... args) {
-{
   log(level::debug, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::info(const wchar_t *fmt, const Args &... args) {
-{
   log(level::info, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::warn(const wchar_t *fmt, const Args &... args) {
-{
   log(level::warn, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::error(const wchar_t *fmt, const Args &... args) {
-{
   log(level::err, fmt, args...);
 }
 
 template <typename... Args>
-inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
+inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args) {
-{
   log(level::critical, fmt, args...);
 }
 
@@ -311,63 +280,53 @@ inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
 //
 // name and level
 //
-inline const std::string &spdlog::logger::name() const
+inline const std::string &spdlog::logger::name() const { return name_; }
-{
-    return name_;
-}
 
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
+inline void spdlog::logger::set_level(spdlog::level::level_enum log_level) {
-{
   level_.store(log_level);
 }
 
-inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
+inline void spdlog::logger::set_error_handler(
-{
+    spdlog::log_err_handler err_handler) {
   err_handler_ = std::move(err_handler);
 }
 
-inline spdlog::log_err_handler spdlog::logger::error_handler() const
+inline spdlog::log_err_handler spdlog::logger::error_handler() const {
-{
   return err_handler_;
 }
 
-inline void spdlog::logger::flush()
+inline void spdlog::logger::flush() {
-{
+  try {
-    try
-    {
     flush_();
   }
   SPDLOG_CATCH_AND_HANDLE
 }
 
-inline void spdlog::logger::flush_on(level::level_enum log_level)
+inline void spdlog::logger::flush_on(level::level_enum log_level) {
-{
   flush_level_.store(log_level);
 }
 
-inline spdlog::level::level_enum spdlog::logger::flush_level() const
+inline spdlog::level::level_enum spdlog::logger::flush_level() const {
-{
+  return static_cast<spdlog::level::level_enum>(
-    return static_cast<spdlog::level::level_enum>(flush_level_.load(std::memory_order_relaxed));
+      flush_level_.load(std::memory_order_relaxed));
 }
 
-inline bool spdlog::logger::should_flush_(const details::log_msg &msg)
+inline bool spdlog::logger::should_flush_(const details::log_msg &msg) {
-{
   auto flush_level = flush_level_.load(std::memory_order_relaxed);
   return (msg.level >= flush_level) && (msg.level != level::off);
 }
 
-inline spdlog::level::level_enum spdlog::logger::default_level()
+inline spdlog::level::level_enum spdlog::logger::default_level() {
-{
   return static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL);
 }
 
-inline spdlog::level::level_enum spdlog::logger::level() const
+inline spdlog::level::level_enum spdlog::logger::level() const {
-{
+  return static_cast<spdlog::level::level_enum>(
-    return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
+      level_.load(std::memory_order_relaxed));
 }
 
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
+inline bool spdlog::logger::should_log(
-{
+    spdlog::level::level_enum msg_level) const {
   return msg_level >= level_.load(std::memory_order_relaxed);
 }
 
@@ -375,65 +334,54 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
 // protected virtual called at end of each user log call (if enabled) by the
 // line_logger
 //
-inline void spdlog::logger::sink_it_(details::log_msg &msg)
+inline void spdlog::logger::sink_it_(details::log_msg &msg) {
-{
 #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
   incr_msg_counter_(msg);
 #endif
-    for (auto &sink : sinks_)
+  for (auto &sink : sinks_) {
-    {
+    if (sink->should_log(msg.level)) {
-        if (sink->should_log(msg.level))
-        {
       sink->log(msg);
     }
   }
 
-    if (should_flush_(msg))
+  if (should_flush_(msg)) {
-    {
     flush_();
   }
 }
 
-inline void spdlog::logger::flush_()
+inline void spdlog::logger::flush_() {
-{
+  for (auto &sink : sinks_) {
-    for (auto &sink : sinks_)
-    {
     sink->flush();
   }
 }
 
-inline void spdlog::logger::default_err_handler_(const std::string &msg)
+inline void spdlog::logger::default_err_handler_(const std::string &msg) {
-{
   auto now = time(nullptr);
-    if (now - last_err_time_ < 60)
+  if (now - last_err_time_ < 60) {
-    {
     return;
   }
   last_err_time_ = now;
   auto tm_time = details::os::localtime(now);
   char date_buf[100];
   std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
-    fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
+  fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(),
+             msg);
 }
 
-inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg)
+inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg) {
-{
   msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
 }
 
-inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const
+inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const {
-{
   return sinks_;
 }
 
-inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
+inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() { return sinks_; }
-{
-    return sinks_;
-}
 
-inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(std::string logger_name)
+inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(
-{
+    std::string logger_name) {
-    auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end());
+  auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name),
+                                                 sinks_.begin(), sinks_.end());
   cloned->set_level(this->level());
   cloned->flush_on(this->flush_level());
   cloned->set_error_handler(this->error_handler());

src/cpp/include/deps/spdlog/details/mpmc_blocking_q.h

@@ -12,28 +12,23 @@
 // dequeue_for(..) - will block until the queue is not empty or timeout have
 // passed.
 
-#include "spdlog/details/circular_q.h"
-
 #include <condition_variable>
 #include <mutex>
 
+#include "spdlog/details/circular_q.h"
+
 namespace spdlog {
 namespace details {
 
 template <typename T>
-class mpmc_blocking_queue
+class mpmc_blocking_queue {
-{
  public:
   using item_type = T;
-    explicit mpmc_blocking_queue(size_t max_items)
+  explicit mpmc_blocking_queue(size_t max_items) : q_(max_items) {}
-        : q_(max_items)
-    {
-    }
 
 #ifndef __MINGW32__
   // try to enqueue and block if no room left
-    void enqueue(T &&item)
+  void enqueue(T &&item) {
-    {
     {
       std::unique_lock<std::mutex> lock(queue_mutex_);
       pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@@ -43,8 +38,7 @@ public:
   }
 
   // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
+  void enqueue_nowait(T &&item) {
-    {
     {
       std::unique_lock<std::mutex> lock(queue_mutex_);
       q_.push_back(std::move(item));
@@ -54,12 +48,11 @@ public:
 
   // try to dequeue item. if no item found. wait upto timeout and try again
   // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+  bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
-    {
     {
       std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+      if (!push_cv_.wait_for(lock, wait_duration,
-            {
+                             [this] { return !this->q_.empty(); })) {
         return false;
       }
       q_.pop_front(popped_item);
@@ -73,8 +66,7 @@ public:
   // so release the mutex at the very end each function.
 
   // try to enqueue and block if no room left
-    void enqueue(T &&item)
+  void enqueue(T &&item) {
-    {
     std::unique_lock<std::mutex> lock(queue_mutex_);
     pop_cv_.wait(lock, [this] { return !this->q_.full(); });
     q_.push_back(std::move(item));
@@ -82,8 +74,7 @@ public:
   }
 
   // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
+  void enqueue_nowait(T &&item) {
-    {
     std::unique_lock<std::mutex> lock(queue_mutex_);
     q_.push_back(std::move(item));
     push_cv_.notify_one();
@@ -91,11 +82,10 @@ public:
 
   // try to dequeue item. if no item found. wait upto timeout and try again
   // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+  bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
-    {
     std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+    if (!push_cv_.wait_for(lock, wait_duration,
-        {
+                           [this] { return !this->q_.empty(); })) {
       return false;
     }
     q_.pop_front(popped_item);
@@ -105,8 +95,7 @@ public:
 
 #endif
 
-    size_t overrun_counter()
+  size_t overrun_counter() {
-    {
     std::unique_lock<std::mutex> lock(queue_mutex_);
     return q_.overrun_counter();
   }

src/cpp/include/deps/spdlog/details/null_mutex.h

@@ -10,35 +10,21 @@
 
 namespace spdlog {
 namespace details {
-struct null_mutex
+struct null_mutex {
-{
   void lock() {}
   void unlock() {}
-    bool try_lock()
+  bool try_lock() { return true; }
-    {
-        return true;
-    }
 };
 
-struct null_atomic_int
+struct null_atomic_int {
-{
   int value;
   null_atomic_int() = default;
 
-    explicit null_atomic_int(int val)
+  explicit null_atomic_int(int val) : value(val) {}
-        : value(val)
-    {
-    }
 
-    int load(std::memory_order) const
+  int load(std::memory_order) const { return value; }
-    {
-        return value;
-    }
 
-    void store(int val)
+  void store(int val) { value = val; }
-    {
-        value = val;
-    }
 };
 
 }  // namespace details

src/cpp/include/deps/spdlog/details/os.h

@@ -4,7 +4,8 @@
 //
 #pragma once
 
-#include "../common.h"
+#include <sys/stat.h>
+#include <sys/types.h>
 
 #include <algorithm>
 #include <chrono>
@@ -14,10 +15,10 @@
 #include <ctime>
 #include <functional>
 #include <string>
-#include <sys/stat.h>
-#include <sys/types.h>
 #include <thread>
 
+#include "../common.h"
+
 #ifdef _WIN32
 
 #ifndef NOMINMAX
@@ -57,22 +58,20 @@ namespace spdlog {
 namespace details {
 namespace os {
 
-inline spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
+inline spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
-{
-
 #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
   timespec ts;
   ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
   return std::chrono::time_point<log_clock, typename log_clock::duration>(
-        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+      std::chrono::duration_cast<typename log_clock::duration>(
+          std::chrono::seconds(ts.tv_sec) +
+          std::chrono::nanoseconds(ts.tv_nsec)));
 
 #else
   return log_clock::now();
 #endif
 }
-inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
-{
-
 #ifdef _WIN32
   std::tm tm;
   localtime_s(&tm, &time_tt);
@@ -83,15 +82,12 @@ inline std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
   return tm;
 }
 
-inline std::tm localtime() SPDLOG_NOEXCEPT
+inline std::tm localtime() SPDLOG_NOEXCEPT {
-{
   std::time_t now_t = time(nullptr);
   return localtime(now_t);
 }
 
-inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
-{
-
 #ifdef _WIN32
   std::tm tm;
   gmtime_s(&tm, &time_tt);
@@ -102,8 +98,7 @@ inline std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
   return tm;
 }
 
-inline std::tm gmtime() SPDLOG_NOEXCEPT
+inline std::tm gmtime() SPDLOG_NOEXCEPT {
-{
   std::time_t now_t = time(nullptr);
   return gmtime(now_t);
 }
@@ -126,9 +121,7 @@ SPDLOG_CONSTEXPR static const char folder_sep = '\\';
 SPDLOG_CONSTEXPR static const char folder_sep = '/';
 #endif
 
-inline void prevent_child_fd(FILE *f)
+inline void prevent_child_fd(FILE *f) {
-{
-
 #ifdef _WIN32
 #if !defined(__cplusplus_winrt)
   auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
@@ -137,16 +130,15 @@ inline void prevent_child_fd(FILE *f)
 #endif
 #else
   auto fd = fileno(f);
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+  if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
-    {
     throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
   }
 #endif
 }
 
 // fopen_s on non windows for writing
-inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+inline bool fopen_s(FILE **fp, const filename_t &filename,
-{
+                    const filename_t &mode) {
 #ifdef _WIN32
 #ifdef SPDLOG_WCHAR_FILENAMES
   *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
@@ -158,16 +150,14 @@ inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mod
 #endif
 
 #ifdef SPDLOG_PREVENT_CHILD_FD
-    if (*fp != nullptr)
+  if (*fp != nullptr) {
-    {
     prevent_child_fd(*fp);
   }
 #endif
   return *fp == nullptr;
 }
 
-inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT {
-{
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
   return _wremove(filename.c_str());
 #else
@@ -175,8 +165,8 @@ inline int remove(const filename_t &filename) SPDLOG_NOEXCEPT
 #endif
 }
 
-inline int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
+inline int rename(const filename_t &filename1,
-{
+                  const filename_t &filename2) SPDLOG_NOEXCEPT {
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
   return _wrename(filename1.c_str(), filename2.c_str());
 #else
@@ -185,15 +175,15 @@ inline int rename(const filename_t &filename1, const filename_t &filename2) SPDL
 }
 
 // Return if file exists
-inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
-{
 #ifdef _WIN32
 #ifdef SPDLOG_WCHAR_FILENAMES
   auto attribs = GetFileAttributesW(filename.c_str());
 #else
   auto attribs = GetFileAttributesA(filename.c_str());
 #endif
-    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
+  return (attribs != INVALID_FILE_ATTRIBUTES &&
+          !(attribs & FILE_ATTRIBUTE_DIRECTORY));
 #else  // common linux/unix all have the stat system call
   struct stat buffer;
   return (stat(filename.c_str(), &buffer) == 0);
@@ -201,25 +191,21 @@ inline bool file_exists(const filename_t &filename) SPDLOG_NOEXCEPT
 }
 
 // Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
+inline size_t filesize(FILE *f) {
-{
+  if (f == nullptr) {
-    if (f == nullptr)
-    {
     throw spdlog_ex("Failed getting file size. fd is null");
   }
 #if defined(_WIN32) && !defined(__CYGWIN__)
   int fd = _fileno(f);
 #if _WIN64  // 64 bits
   __int64 ret = _filelengthi64(fd);
-    if (ret >= 0)
+  if (ret >= 0) {
-    {
     return static_cast<size_t>(ret);
   }
 
 #else  // windows 32 bits
   long ret = _filelength(fd);
-    if (ret >= 0)
+  if (ret >= 0) {
-    {
     return static_cast<size_t>(ret);
   }
 #endif
@@ -227,17 +213,16 @@ inline size_t filesize(FILE *f)
 #else  // unix
   int fd = fileno(f);
 // 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
+#if !defined(__FreeBSD__) && !defined(__APPLE__) && \
+    (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
   struct stat64 st;
-    if (fstat64(fd, &st) == 0)
+  if (fstat64(fd, &st) == 0) {
-    {
     return static_cast<size_t>(st.st_size);
   }
 #else  // unix 32 bits or cygwin
   struct stat st;
 
-    if (fstat(fd, &st) == 0)
+  if (fstat(fd, &st) == 0) {
-    {
     return static_cast<size_t>(st.st_size);
   }
 #endif
@@ -246,9 +231,7 @@ inline size_t filesize(FILE *f)
 }
 
 // Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
+inline int utc_minutes_offset(const std::tm &tm = details::os::localtime()) {
-{
-
 #ifdef _WIN32
 #if _WIN32_WINNT < _WIN32_WINNT_WS08
   TIME_ZONE_INFORMATION tzinfo;
@@ -261,12 +244,9 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
     throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
 
   int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
+  if (tm.tm_isdst) {
-    {
     offset -= tzinfo.DaylightBias;
-    }
+  } else {
-    else
-    {
     offset -= tzinfo.StandardBias;
   }
   return offset;
@@ -274,10 +254,10 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
 
 #if defined(sun) || defined(__sun) || defined(_AIX)
   // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper
+  struct helper {
-    {
+    static long int calculate_gmt_offset(
-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+        const std::tm &localtm = details::os::localtime(),
-        {
+        const std::tm &gmtm = details::os::gmtime()) {
       int local_year = localtm.tm_year + (1900 - 1);
       int gmt_year = gmtm.tm_year + (1900 - 1);
 
@@ -287,7 +267,8 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
           gmtm.tm_yday
 
           // + intervening leap days
-                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+          + ((local_year >> 2) - (gmt_year >> 2)) -
+          (local_year / 100 - gmt_year / 100) +
           ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
 
           // + difference in years * 365 */
@@ -313,8 +294,7 @@ inline int utc_minutes_offset(const std::tm &tm = details::os::localtime())
 // Return current thread id as size_t
 // It exists because the std::this_thread::get_id() is much slower(especially
 // under VS 2013)
-inline size_t _thread_id() SPDLOG_NOEXCEPT
+inline size_t _thread_id() SPDLOG_NOEXCEPT {
-{
 #ifdef _WIN32
   return static_cast<size_t>(::GetCurrentThreadId());
 #elif __linux__
@@ -331,13 +311,13 @@ inline size_t _thread_id() SPDLOG_NOEXCEPT
   pthread_threadid_np(nullptr, &tid);
   return static_cast<size_t>(tid);
 #else  // Default to standard C++11 (other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+  return static_cast<size_t>(
+      std::hash<std::thread::id>()(std::this_thread::get_id()));
 #endif
 }
 
 // Return current thread id as size_t (from thread local storage)
-inline size_t thread_id() SPDLOG_NOEXCEPT
+inline size_t thread_id() SPDLOG_NOEXCEPT {
-{
 #if defined(SPDLOG_NO_TLS)
   return _thread_id();
 #else  // cache thread id in tls
@@ -348,8 +328,7 @@ inline size_t thread_id() SPDLOG_NOEXCEPT
 
 // This is avoid msvc issue in sleep_for that happens if the clock changes.
 // See https://github.com/gabime/spdlog/issues/609
-inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
+inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT {
-{
 #if defined(_WIN32)
   ::Sleep(milliseconds);
 #else
@@ -360,22 +339,18 @@ inline void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
 // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 #define SPDLOG_FILENAME_T(s) L##s
-inline std::string filename_to_str(const filename_t &filename)
+inline std::string filename_to_str(const filename_t &filename) {
-{
   std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
   return c.to_bytes(filename);
 }
 #else
 #define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t &filename)
+inline std::string filename_to_str(const filename_t &filename) {
-{
   return filename;
 }
 #endif
 
-inline int pid()
+inline int pid() {
-{
-
 #ifdef _WIN32
   return static_cast<int>(::GetCurrentProcessId());
 #else
@@ -385,31 +360,29 @@ inline int pid()
 
 // Determine if the terminal supports colors
 // Source: https://github.com/agauniyal/rang/
-inline bool is_color_terminal() SPDLOG_NOEXCEPT
+inline bool is_color_terminal() SPDLOG_NOEXCEPT {
-{
 #ifdef _WIN32
   return true;
 #else
   static constexpr const char *Terms[] = {
-        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"};
+      "ansi",  "color", "console", "cygwin", "gnome",  "konsole", "kterm",
+      "linux", "msys",  "putty",   "rxvt",   "screen", "vt100",   "xterm"};
 
   const char *env_p = std::getenv("TERM");
-    if (env_p == nullptr)
+  if (env_p == nullptr) {
-    {
     return false;
   }
 
-    static const bool result =
+  static const bool result = std::any_of(
-        std::any_of(std::begin(Terms), std::end(Terms), [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
+      std::begin(Terms), std::end(Terms),
+      [&](const char *term) { return std::strstr(env_p, term) != nullptr; });
   return result;
 #endif
 }
 
 // Detrmine if the terminal attached
 // Source: https://github.com/agauniyal/rang/
-inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+inline bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
-{
-
 #ifdef _WIN32
   return _isatty(_fileno(file)) != 0;
 #else

src/cpp/include/deps/spdlog/details/periodic_worker.h

@@ -10,7 +10,8 @@
 //
 // RAII over the owned thread:
 //    creates the thread on construction.
-//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
+//    stops and joins the thread on destruction (if the thread is executing a
+//    callback, wait for it to finish first).
 
 #include <chrono>
 #include <condition_variable>
@@ -20,23 +21,20 @@
 namespace spdlog {
 namespace details {
 
-class periodic_worker
+class periodic_worker {
-{
  public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+  periodic_worker(const std::function<void()> &callback_fun,
-    {
+                  std::chrono::seconds interval) {
     active_ = (interval > std::chrono::seconds::zero());
-        if (!active_)
+    if (!active_) {
-        {
       return;
     }
 
     worker_thread_ = std::thread([this, callback_fun, interval]() {
-            for (;;)
+      for (;;) {
-            {
         std::unique_lock<std::mutex> lock(this->mutex_);
-                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+        if (this->cv_.wait_for(lock, interval,
-                {
+                               [this] { return !this->active_; })) {
           return;  // active_ == false, so exit this thread
         }
         callback_fun();
@@ -48,10 +46,8 @@ public:
   periodic_worker &operator=(const periodic_worker &) = delete;
 
   // stop the worker thread and join it
-    ~periodic_worker()
+  ~periodic_worker() {
-    {
+    if (worker_thread_.joinable()) {
-        if (worker_thread_.joinable())
-        {
       {
         std::lock_guard<std::mutex> lock(mutex_);
         active_ = false;

src/cpp/include/deps/spdlog/details/registry.h

@@ -33,174 +33,146 @@ namespace spdlog {
 namespace details {
 class thread_pool;
 
-class registry
+class registry {
-{
  public:
   registry(const registry &) = delete;
   registry &operator=(const registry &) = delete;
 
-    void register_logger(std::shared_ptr<logger> new_logger)
+  void register_logger(std::shared_ptr<logger> new_logger) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     register_logger_(std::move(new_logger));
   }
 
-    void initialize_logger(std::shared_ptr<logger> new_logger)
+  void initialize_logger(std::shared_ptr<logger> new_logger) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     new_logger->set_formatter(formatter_->clone());
 
-        if (err_handler_)
+    if (err_handler_) {
-        {
       new_logger->set_error_handler(err_handler_);
     }
 
     new_logger->set_level(level_);
     new_logger->flush_on(flush_level_);
 
-        if (automatic_registration_)
+    if (automatic_registration_) {
-        {
       register_logger_(std::move(new_logger));
     }
   }
 
-    std::shared_ptr<logger> get(const std::string &logger_name)
+  std::shared_ptr<logger> get(const std::string &logger_name) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     auto found = loggers_.find(logger_name);
     return found == loggers_.end() ? nullptr : found->second;
   }
 
-    std::shared_ptr<logger> default_logger()
+  std::shared_ptr<logger> default_logger() {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     return default_logger_;
   }
 
   // Return raw ptr to the default logger.
   // To be used directly by the spdlog default api (e.g. spdlog::info)
-    // This make the default API faster, but cannot be used concurrently with set_default_logger().
+  // This make the default API faster, but cannot be used concurrently with
-    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+  // set_default_logger(). e.g do not call set_default_logger() from one thread
-    logger *get_default_raw()
+  // while calling spdlog::info() from another.
-    {
+  logger *get_default_raw() { return default_logger_.get(); }
-        return default_logger_.get();
-    }
 
   // set default logger.
-    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+  // default logger is stored in default_logger_ (for faster retrieval) and in
-    void set_default_logger(std::shared_ptr<logger> new_default_logger)
+  // the loggers_ map.
-    {
+  void set_default_logger(std::shared_ptr<logger> new_default_logger) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     // remove previous default logger from the map
-        if (default_logger_ != nullptr)
+    if (default_logger_ != nullptr) {
-        {
       loggers_.erase(default_logger_->name());
     }
-        if (new_default_logger != nullptr)
+    if (new_default_logger != nullptr) {
-        {
       loggers_[new_default_logger->name()] = new_default_logger;
     }
     default_logger_ = std::move(new_default_logger);
   }
 
-    void set_tp(std::shared_ptr<thread_pool> tp)
+  void set_tp(std::shared_ptr<thread_pool> tp) {
-    {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     tp_ = std::move(tp);
   }
 
-    std::shared_ptr<thread_pool> get_tp()
+  std::shared_ptr<thread_pool> get_tp() {
-    {
     std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
     return tp_;
   }
 
-    // Set global formatter. Each sink in each logger will get a clone of this object
+  // Set global formatter. Each sink in each logger will get a clone of this
-    void set_formatter(std::unique_ptr<formatter> formatter)
+  // object
-    {
+  void set_formatter(std::unique_ptr<formatter> formatter) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     formatter_ = std::move(formatter);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       l.second->set_formatter(formatter_->clone());
     }
   }
 
-    void set_level(level::level_enum log_level)
+  void set_level(level::level_enum log_level) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       l.second->set_level(log_level);
     }
     level_ = log_level;
   }
 
-    void flush_on(level::level_enum log_level)
+  void flush_on(level::level_enum log_level) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       l.second->flush_on(log_level);
     }
     flush_level_ = log_level;
   }
 
-    void flush_every(std::chrono::seconds interval)
+  void flush_every(std::chrono::seconds interval) {
-    {
     std::lock_guard<std::mutex> lock(flusher_mutex_);
     std::function<void()> clbk = std::bind(&registry::flush_all, this);
     periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
   }
 
-    void set_error_handler(log_err_handler handler)
+  void set_error_handler(log_err_handler handler) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       l.second->set_error_handler(handler);
     }
     err_handler_ = handler;
   }
 
-    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+  void apply_all(
-    {
+      const std::function<void(const std::shared_ptr<logger>)> &fun) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       fun(l.second);
     }
   }
 
-    void flush_all()
+  void flush_all() {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
-        for (auto &l : loggers_)
+    for (auto &l : loggers_) {
-        {
       l.second->flush();
     }
   }
 
-    void drop(const std::string &logger_name)
+  void drop(const std::string &logger_name) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     loggers_.erase(logger_name);
-        if (default_logger_ && default_logger_->name() == logger_name)
+    if (default_logger_ && default_logger_->name() == logger_name) {
-        {
       default_logger_.reset();
     }
   }
 
-    void drop_all()
+  void drop_all() {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     loggers_.clear();
     default_logger_.reset();
   }
 
   // clean all resources and threads started by the registry
-    void shutdown()
+  void shutdown() {
-    {
     {
       std::lock_guard<std::mutex> lock(flusher_mutex_);
       periodic_flusher_.reset();
@@ -214,30 +186,23 @@ public:
     }
   }
 
-    std::recursive_mutex &tp_mutex()
+  std::recursive_mutex &tp_mutex() { return tp_mutex_; }
-    {
-        return tp_mutex_;
-    }
 
-    void set_automatic_registration(bool automatic_regsistration)
+  void set_automatic_registration(bool automatic_regsistration) {
-    {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     automatic_registration_ = automatic_regsistration;
   }
 
-    static registry &instance()
+  static registry &instance() {
-    {
     static registry s_instance;
     return s_instance;
   }
 
  private:
-    registry()
+  registry() : formatter_(new pattern_formatter()) {
-        : formatter_(new pattern_formatter())
-    {
-
 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-        // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+    // create default logger (ansicolor_stdout_sink_mt or
+    // wincolor_stdout_sink_mt in windows).
 #ifdef _WIN32
     auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
 #else
@@ -245,7 +210,8 @@ private:
 #endif
 
     const char *default_logger_name = "";
-        default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
+    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name,
+                                                       std::move(color_sink));
     loggers_[default_logger_name] = default_logger_;
 
 #endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
@@ -253,16 +219,13 @@ private:
 
   ~registry() = default;
 
-    void throw_if_exists_(const std::string &logger_name)
+  void throw_if_exists_(const std::string &logger_name) {
-    {
+    if (loggers_.find(logger_name) != loggers_.end()) {
-        if (loggers_.find(logger_name) != loggers_.end())
-        {
       throw spdlog_ex("logger with name '" + logger_name + "' already exists");
     }
   }
 
-    void register_logger_(std::shared_ptr<logger> new_logger)
+  void register_logger_(std::shared_ptr<logger> new_logger) {
-    {
     auto logger_name = new_logger->name();
     throw_if_exists_(logger_name);
     loggers_[logger_name] = std::move(new_logger);

src/cpp/include/deps/spdlog/details/thread_pool.h

@@ -1,31 +1,25 @@
 #pragma once
 
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/mpmc_blocking_q.h"
-#include "spdlog/details/os.h"
-
 #include <chrono>
 #include <memory>
 #include <thread>
 #include <vector>
 
+#include "spdlog/details/fmt_helper.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/mpmc_blocking_q.h"
+#include "spdlog/details/os.h"
+
 namespace spdlog {
 namespace details {
 
 using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
 
-enum class async_msg_type
+enum class async_msg_type { log, flush, terminate };
-{
-    log,
-    flush,
-    terminate
-};
 
 // Async msg to move to/from the queue
 // Movable only. should never be copied
-struct async_msg
+struct async_msg {
-{
   async_msg_type msg_type;
   level::level_enum level;
   log_clock::time_point time;
@@ -44,19 +38,17 @@ struct async_msg
 
 // support for vs2013 move
 #if defined(_MSC_VER) && _MSC_VER <= 1800
-    async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type),
+  async_msg(async_msg &&other) SPDLOG_NOEXCEPT
+      : msg_type(other.msg_type),
         level(other.level),
         time(other.time),
         thread_id(other.thread_id),
         raw(move(other.raw)),
         msg_id(other.msg_id),
         source(other.source),
-                                                   worker_ptr(std::move(other.worker_ptr))
+        worker_ptr(std::move(other.worker_ptr)) {}
-    {
-    }
 
-    async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT
+  async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT {
-    {
     msg_type = other.msg_type;
     level = other.level;
     time = other.time;
@@ -73,38 +65,33 @@ struct async_msg
 #endif
 
   // construct from log_msg with given type
-    async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &m)
+  async_msg(async_logger_ptr &&worker, async_msg_type the_type,
-        : msg_type(the_type)
+            details::log_msg &m)
-        , level(m.level)
+      : msg_type(the_type),
-        , time(m.time)
+        level(m.level),
-        , thread_id(m.thread_id)
+        time(m.time),
-        , msg_id(m.msg_id)
+        thread_id(m.thread_id),
-        , source(m.source)
+        msg_id(m.msg_id),
-        , worker_ptr(std::move(worker))
+        source(m.source),
-    {
+        worker_ptr(std::move(worker)) {
     fmt_helper::append_string_view(m.payload, raw);
   }
 
   async_msg(async_logger_ptr &&worker, async_msg_type the_type)
-        : msg_type(the_type)
+      : msg_type(the_type),
-        , level(level::off)
+        level(level::off),
-        , time()
+        time(),
-        , thread_id(0)
+        thread_id(0),
-        , msg_id(0)
+        msg_id(0),
-        , source()
+        source(),
-        , worker_ptr(std::move(worker))
+        worker_ptr(std::move(worker)) {}
-    {
-    }
 
-    explicit async_msg(async_msg_type the_type)
+  explicit async_msg(async_msg_type the_type) : async_msg(nullptr, the_type) {}
-        : async_msg(nullptr, the_type)
-    {
-    }
 
   // copy into log_msg
-    log_msg to_log_msg()
+  log_msg to_log_msg() {
-    {
+    log_msg msg(&worker_ptr->name(), level,
-        log_msg msg(&worker_ptr->name(), level, string_view_t(raw.data(), raw.size()));
+                string_view_t(raw.data(), raw.size()));
     msg.time = time;
     msg.thread_id = thread_id;
     msg.msg_id = msg_id;
@@ -115,117 +102,98 @@ struct async_msg
   }
 };
 
-class thread_pool
+class thread_pool {
-{
  public:
   using item_type = async_msg;
   using q_type = details::mpmc_blocking_queue<item_type>;
 
-    thread_pool(size_t q_max_items, size_t threads_n)
+  thread_pool(size_t q_max_items, size_t threads_n) : q_(q_max_items) {
-        : q_(q_max_items)
-    {
     // std::cout << "thread_pool()  q_size_bytes: " << q_size_bytes <<
     // "\tthreads_n: " << threads_n << std::endl;
-        if (threads_n == 0 || threads_n > 1000)
+    if (threads_n == 0 || threads_n > 1000) {
-        {
+      throw spdlog_ex(
-            throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+          "spdlog::thread_pool(): invalid threads_n param (valid "
           "range is 1-1000)");
     }
-        for (size_t i = 0; i < threads_n; i++)
+    for (size_t i = 0; i < threads_n; i++) {
-        {
       threads_.emplace_back(&thread_pool::worker_loop_, this);
     }
   }
 
   // message all threads to terminate gracefully join them
-    ~thread_pool()
+  ~thread_pool() {
-    {
+    try {
-        try
+      for (size_t i = 0; i < threads_.size(); i++) {
-        {
+        post_async_msg_(async_msg(async_msg_type::terminate),
-            for (size_t i = 0; i < threads_.size(); i++)
+                        async_overflow_policy::block);
-            {
-                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
       }
 
-            for (auto &t : threads_)
+      for (auto &t : threads_) {
-            {
         t.join();
       }
-        }
+    } catch (...) {
-        catch (...)
-        {
     }
   }
 
   thread_pool(const thread_pool &) = delete;
   thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy)
+  void post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg,
-    {
+                async_overflow_policy overflow_policy) {
     async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
     post_async_msg_(std::move(async_m), overflow_policy);
   }
 
-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+  void post_flush(async_logger_ptr &&worker_ptr,
-    {
+                  async_overflow_policy overflow_policy) {
-        post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush),
+                    overflow_policy);
   }
 
-    size_t overrun_counter()
+  size_t overrun_counter() { return q_.overrun_counter(); }
-    {
-        return q_.overrun_counter();
-    }
 
  private:
   q_type q_;
 
   std::vector<std::thread> threads_;
 
-    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+  void post_async_msg_(async_msg &&new_msg,
-    {
+                       async_overflow_policy overflow_policy) {
-        if (overflow_policy == async_overflow_policy::block)
+    if (overflow_policy == async_overflow_policy::block) {
-        {
       q_.enqueue(std::move(new_msg));
-        }
+    } else {
-        else
-        {
       q_.enqueue_nowait(std::move(new_msg));
     }
   }
 
-    void worker_loop_()
+  void worker_loop_() {
-    {
+    while (process_next_msg_()) {
-        while (process_next_msg_()) {};
+    };
   }
 
   // process next message in the queue
   // return true if this thread should still be active (while no terminate msg
   // was received)
-    bool process_next_msg_()
+  bool process_next_msg_() {
-    {
     async_msg incoming_async_msg;
-        bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+    bool dequeued =
-        if (!dequeued)
+        q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
-        {
+    if (!dequeued) {
       return true;
     }
 
-        switch (incoming_async_msg.msg_type)
+    switch (incoming_async_msg.msg_type) {
-        {
+      case async_msg_type::log: {
-        case async_msg_type::log:
-        {
         auto msg = incoming_async_msg.to_log_msg();
         incoming_async_msg.worker_ptr->backend_log_(msg);
         return true;
       }
-        case async_msg_type::flush:
+      case async_msg_type::flush: {
-        {
         incoming_async_msg.worker_ptr->backend_flush_();
         return true;
       }
 
-        case async_msg_type::terminate:
+      case async_msg_type::terminate: {
-        {
         return false;
       }
     }

src/cpp/include/deps/spdlog/fmt/bin_to_hex.h

@@ -19,29 +19,20 @@
 // std::vector<char> v(200, 0x0b);
 // logger->info("Some buffer {}", spdlog::to_hex(v));
 // char buf[128];
-// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
+// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf),
+// std::end(buf)));
 
 namespace spdlog {
 namespace details {
 
 template <typename It>
-class bytes_range
+class bytes_range {
-{
  public:
   bytes_range(It range_begin, It range_end)
-        : begin_(range_begin)
+      : begin_(range_begin), end_(range_end) {}
-        , end_(range_end)
-    {
-    }
 
-    It begin() const
+  It begin() const { return begin_; }
-    {
+  It end() const { return end_; }
-        return begin_;
-    }
-    It end() const
-    {
-        return end_;
-    }
 
  private:
   It begin_, end_;
@@ -50,17 +41,18 @@ private:
 
 // create a bytes_range that wraps the given container
 template <typename Container>
-inline details::bytes_range<typename Container::const_iterator> to_hex(const Container &container)
+inline details::bytes_range<typename Container::const_iterator> to_hex(
-{
+    const Container &container) {
-    static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
+  static_assert(sizeof(typename Container::value_type) == 1,
+                "sizeof(Container::value_type) != 1");
   using Iter = typename Container::const_iterator;
   return details::bytes_range<Iter>(std::begin(container), std::end(container));
 }
 
 // create bytes_range from ranges
 template <typename It>
-inline details::bytes_range<It> to_hex(const It range_begin, const It range_end)
+inline details::bytes_range<It> to_hex(const It range_begin,
-{
+                                       const It range_end) {
   return details::bytes_range<It>(range_begin, range_end);
 }
 
@@ -69,8 +61,7 @@ inline details::bytes_range<It> to_hex(const It range_begin, const It range_end)
 namespace fmt {
 
 template <typename T>
-struct formatter<spdlog::details::bytes_range<T>>
+struct formatter<spdlog::details::bytes_range<T>> {
-{
   const std::size_t line_size = 100;
   const char delimiter = ' ';
 
@@ -81,13 +72,10 @@ struct formatter<spdlog::details::bytes_range<T>>
 
   // parse the format string flags
   template <typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    {
     auto it = ctx.begin();
-        while (*it && *it != '}')
+    while (*it && *it != '}') {
-        {
+      switch (*it) {
-            switch (*it)
-            {
         case 'X':
           use_uppercase = true;
           break;
@@ -109,8 +97,8 @@ struct formatter<spdlog::details::bytes_range<T>>
 
   // format the given bytes range as hex
   template <typename FormatContext, typename Container>
-    auto format(const spdlog::details::bytes_range<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
+  auto format(const spdlog::details::bytes_range<Container> &the_range,
-    {
+              FormatContext &ctx) -> decltype(ctx.out()) {
     SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
     SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
     const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
@@ -119,13 +107,11 @@ struct formatter<spdlog::details::bytes_range<T>>
     std::size_t column = line_size;
     auto inserter = ctx.begin();
 
-        for (auto &item : the_range)
+    for (auto &item : the_range) {
-        {
       auto ch = static_cast<unsigned char>(item);
       pos++;
 
-            if (put_newlines && column >= line_size)
+      if (put_newlines && column >= line_size) {
-            {
         column = put_newline(inserter, pos);
 
         // put first byte without delimiter in front of it
@@ -135,8 +121,7 @@ struct formatter<spdlog::details::bytes_range<T>>
         continue;
       }
 
-            if (put_delimiters)
+      if (put_delimiters) {
-            {
         *inserter++ = delimiter;
         ++column;
       }
@@ -151,20 +136,16 @@ struct formatter<spdlog::details::bytes_range<T>>
   // put newline(and position header)
   // return the next column
   template <typename It>
-    std::size_t put_newline(It inserter, std::size_t pos)
+  std::size_t put_newline(It inserter, std::size_t pos) {
-    {
 #ifdef _WIN32
     *inserter++ = '\r';
 #endif
     *inserter++ = '\n';
 
-        if (put_positions)
+    if (put_positions) {
-        {
       fmt::format_to(inserter, "{:<04X}: ", pos - 1);
       return 7;
-        }
+    } else {
-        else
-        {
       return 1;
     }
   }

src/cpp/include/deps/spdlog/fmt/bundled/chrono.h

@@ -8,14 +8,14 @@
 #ifndef FMT_CHRONO_H_
 #define FMT_CHRONO_H_
 
-#include "format.h"
-#include "locale.h"
-
 #include <chrono>
 #include <ctime>
 #include <locale>
 #include <sstream>
 
+#include "format.h"
+#include "locale.h"
+
 FMT_BEGIN_NAMESPACE
 
 namespace internal {
@@ -28,8 +28,9 @@ enum class numeric_system {
 
 // Parses a put_time-like format string and invokes handler actions.
 template <typename Char, typename Handler>
-FMT_CONSTEXPR const Char *parse_chrono_format(
+FMT_CONSTEXPR const Char *parse_chrono_format(const Char *begin,
-    const Char *begin, const Char *end, Handler &&handler) {
+                                              const Char *end,
+                                              Handler &&handler) {
   auto ptr = begin;
   while (ptr != end) {
     auto c = *ptr;
@@ -38,11 +39,9 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
       ++ptr;
       continue;
     }
-    if (begin != ptr)
+    if (begin != ptr) handler.on_text(begin, ptr);
-      handler.on_text(begin, ptr);
     ++ptr;  // consume '%'
-    if (ptr == end)
+    if (ptr == end) throw format_error("invalid format");
-      throw format_error("invalid format");
     c = *ptr++;
     switch (c) {
       case '%':
@@ -127,8 +126,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
         break;
       // Alternative representation:
       case 'E': {
-      if (ptr == end)
+        if (ptr == end) throw format_error("invalid format");
-        throw format_error("invalid format");
         c = *ptr++;
         switch (c) {
           case 'c':
@@ -146,8 +144,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
         break;
       }
       case 'O':
-      if (ptr == end)
+        if (ptr == end) throw format_error("invalid format");
-        throw format_error("invalid format");
         c = *ptr++;
         switch (c) {
           case 'w':
@@ -177,8 +174,7 @@ FMT_CONSTEXPR const Char *parse_chrono_format(
     }
     begin = ptr;
   }
-  if (begin != ptr)
+  if (begin != ptr) handler.on_text(begin, ptr);
-    handler.on_text(begin, ptr);
   return ptr;
 }
 
@@ -213,7 +209,8 @@ struct chrono_format_checker {
 template <typename Int>
 inline int to_int(Int value) {
   FMT_ASSERT(value >= (std::numeric_limits<int>::min)() &&
-             value <= (std::numeric_limits<int>::max)(), "invalid value");
+                 value <= (std::numeric_limits<int>::max)(),
+             "invalid value");
   return static_cast<int>(value);
 }
 
@@ -251,8 +248,7 @@ struct chrono_formatter {
     typedef typename int_traits<int>::main_type main_type;
     main_type n = to_unsigned(value);
     int num_digits = internal::count_digits(n);
-    if (width > num_digits)
+    if (width > num_digits) out = std::fill_n(out, width - num_digits, '0');
-      out = std::fill_n(out, width - num_digits, '0');
     out = format_decimal<char_type>(out, n, num_digits);
   }
 
@@ -286,24 +282,21 @@ struct chrono_formatter {
   void on_tz_name() {}
 
   void on_24_hour(numeric_system ns) {
-    if (ns == numeric_system::standard)
+    if (ns == numeric_system::standard) return write(hour(), 2);
-      return write(hour(), 2);
     auto time = tm();
     time.tm_hour = hour();
     format_localized(time, "%OH");
   }
 
   void on_12_hour(numeric_system ns) {
-    if (ns == numeric_system::standard)
+    if (ns == numeric_system::standard) return write(hour12(), 2);
-      return write(hour12(), 2);
     auto time = tm();
     time.tm_hour = hour();
     format_localized(time, "%OI");
   }
 
   void on_minute(numeric_system ns) {
-    if (ns == numeric_system::standard)
+    if (ns == numeric_system::standard) return write(minute(), 2);
-      return write(minute(), 2);
     auto time = tm();
     time.tm_min = minute();
     format_localized(time, "%OM");
@@ -341,30 +334,84 @@ struct chrono_formatter {
 };
 }  // namespace internal
 
-template <typename Period> FMT_CONSTEXPR const char *get_units() {
+template <typename Period>
+FMT_CONSTEXPR const char *get_units() {
   return FMT_NULL;
 }
-template <> FMT_CONSTEXPR const char *get_units<std::atto>() { return "as"; }
+template <>
-template <> FMT_CONSTEXPR const char *get_units<std::femto>() { return "fs"; }
+FMT_CONSTEXPR const char *get_units<std::atto>() {
-template <> FMT_CONSTEXPR const char *get_units<std::pico>() { return "ps"; }
+  return "as";
-template <> FMT_CONSTEXPR const char *get_units<std::nano>() { return "ns"; }
+}
-template <> FMT_CONSTEXPR const char *get_units<std::micro>() { return "µs"; }
+template <>
-template <> FMT_CONSTEXPR const char *get_units<std::milli>() { return "ms"; }
+FMT_CONSTEXPR const char *get_units<std::femto>() {
-template <> FMT_CONSTEXPR const char *get_units<std::centi>() { return "cs"; }
+  return "fs";
-template <> FMT_CONSTEXPR const char *get_units<std::deci>() { return "ds"; }
+}
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<1>>() { return "s"; }
+template <>
-template <> FMT_CONSTEXPR const char *get_units<std::deca>() { return "das"; }
+FMT_CONSTEXPR const char *get_units<std::pico>() {
-template <> FMT_CONSTEXPR const char *get_units<std::hecto>() { return "hs"; }
+  return "ps";
-template <> FMT_CONSTEXPR const char *get_units<std::kilo>() { return "ks"; }
+}
-template <> FMT_CONSTEXPR const char *get_units<std::mega>() { return "Ms"; }
+template <>
-template <> FMT_CONSTEXPR const char *get_units<std::giga>() { return "Gs"; }
+FMT_CONSTEXPR const char *get_units<std::nano>() {
-template <> FMT_CONSTEXPR const char *get_units<std::tera>() { return "Ts"; }
+  return "ns";
-template <> FMT_CONSTEXPR const char *get_units<std::peta>() { return "Ps"; }
+}
-template <> FMT_CONSTEXPR const char *get_units<std::exa>() { return "Es"; }
+template <>
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<60>>() {
+FMT_CONSTEXPR const char *get_units<std::micro>() {
+  return "µs";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::milli>() {
+  return "ms";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::centi>() {
+  return "cs";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::deci>() {
+  return "ds";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::ratio<1>>() {
+  return "s";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::deca>() {
+  return "das";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::hecto>() {
+  return "hs";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::kilo>() {
+  return "ks";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::mega>() {
+  return "Ms";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::giga>() {
+  return "Gs";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::tera>() {
+  return "Ts";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::peta>() {
+  return "Ps";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::exa>() {
+  return "Es";
+}
+template <>
+FMT_CONSTEXPR const char *get_units<std::ratio<60>>() {
   return "m";
 }
-template <> FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
+template <>
+FMT_CONSTEXPR const char *get_units<std::ratio<3600>>() {
   return "h";
 }
 
@@ -415,13 +462,13 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     if (begin == end) return begin;
     begin = internal::parse_width(begin, end, handler);
     end = parse_chrono_format(begin, end, internal::chrono_format_checker());
-    format_str = basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin));
+    format_str =
+        basic_string_view<Char>(&*begin, internal::to_unsigned(end - begin));
     return end;
   }
 
   template <typename FormatContext>
-  auto format(const duration &d, FormatContext &ctx)
+  auto format(const duration &d, FormatContext &ctx) -> decltype(ctx.out()) {
-      -> decltype(ctx.out()) {
     auto begin = format_str.begin(), end = format_str.end();
     memory_buffer buf;
     typedef output_range<decltype(ctx.out()), Char> range;
@@ -433,8 +480,8 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
         format_to(buf, "{}[{}]s", d.count(), Period::num);
       else
         format_to(buf, "{}[{}/{}]s", d.count(), Period::num, Period::den);
-      internal::handle_dynamic_spec<internal::width_checker>(
+      internal::handle_dynamic_spec<internal::width_checker>(spec.width_,
-        spec.width_, width_ref, ctx);
+                                                             width_ref, ctx);
     } else {
       auto out = std::back_inserter(buf);
       internal::chrono_formatter<FormatContext, decltype(out)> f(ctx, out);

src/cpp/include/deps/spdlog/fmt/bundled/color.h

@@ -227,7 +227,8 @@ struct rgb {
   FMT_CONSTEXPR_DECL rgb(uint32_t hex)
       : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex)&0xFF) {}
   FMT_CONSTEXPR_DECL rgb(color hex)
-    : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
         b(uint32_t(hex) & 0xFF) {}
   uint8_t r;
   uint8_t g;
@@ -238,19 +239,17 @@ namespace internal {
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT
+  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
-    : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT
+                                                           value{} {
-    : is_rgb(true), value{} {
     value.rgb_color = static_cast<uint32_t>(rgb_color);
   }
-  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT
+  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
-    : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
-    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16)
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
-       | (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
   }
-  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT
+  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
-    : is_rgb(), value{} {
+                                                                     value{} {
     value.term_color = static_cast<uint8_t>(term_color);
   }
   bool is_rgb;
@@ -265,7 +264,9 @@ struct color_type {
 class text_style {
  public:
   FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(), set_background_color(), ems(em) {}
+      : set_foreground_color(),
+        set_background_color(),
+        ems(em) {}
 
   FMT_CONSTEXPR text_style &operator|=(const text_style &rhs) {
     if (!set_foreground_color) {
@@ -291,8 +292,8 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-  text_style operator|(text_style lhs, const text_style &rhs) {
+                                            const text_style &rhs) {
     return lhs |= rhs;
   }
 
@@ -320,8 +321,8 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR
+  friend FMT_CONSTEXPR text_style operator&(text_style lhs,
-  text_style operator&(text_style lhs, const text_style &rhs) {
+                                            const text_style &rhs) {
     return lhs &= rhs;
   }
 
@@ -399,8 +400,7 @@ struct ansi_color_escape {
       uint32_t value = text_color.value.term_color;
       // Background ASCII codes are the same as the foreground ones but with
       // 10 more.
-      if (is_background)
+      if (is_background) value += 10u;
-        value += 10u;
 
       std::size_t index = 0;
       buffer[index++] = static_cast<Char>('\x1b');
@@ -430,19 +430,15 @@ struct ansi_color_escape {
   FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
     uint8_t em_codes[4] = {};
     uint8_t em_bits = static_cast<uint8_t>(em);
-    if (em_bits & static_cast<uint8_t>(emphasis::bold))
+    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
-      em_codes[0] = 1;
+    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::italic))
+    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
-      em_codes[1] = 3;
-    if (em_bits & static_cast<uint8_t>(emphasis::underline))
-      em_codes[2] = 4;
     if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
       em_codes[3] = 9;
 
     std::size_t index = 0;
     for (int i = 0; i < 4; ++i) {
-      if (!em_codes[i])
+      if (!em_codes[i]) continue;
-        continue;
       buffer[index++] = static_cast<Char>('\x1b');
       buffer[index++] = static_cast<Char>('[');
       buffer[index++] = static_cast<Char>('0' + em_codes[i]);
@@ -465,20 +461,19 @@ private:
 };
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-make_foreground_color(internal::color_type foreground) FMT_NOEXCEPT {
+    internal::color_type foreground) FMT_NOEXCEPT {
   return ansi_color_escape<Char>(foreground, internal::data::FOREGROUND_COLOR);
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-make_background_color(internal::color_type background) FMT_NOEXCEPT {
+    internal::color_type background) FMT_NOEXCEPT {
   return ansi_color_escape<Char>(background, internal::data::BACKGROUND_COLOR);
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
-make_emphasis(emphasis em) FMT_NOEXCEPT {
   return ansi_color_escape<Char>(em);
 }
 
@@ -512,15 +507,13 @@ template <>
 struct is_string<const std::FILE *> : std::false_type {};
 }  // namespace internal
 
-template <
+template <typename S, typename Char = typename internal::char_t<S>::type>
-  typename S, typename Char = typename internal::char_t<S>::type>
 void vprint(std::FILE *f, const text_style &ts, const S &format,
             basic_format_args<typename buffer_context<Char>::type> args) {
   bool has_style = false;
   if (ts.has_emphasis()) {
     has_style = true;
-    internal::fputs<Char>(
+    internal::fputs<Char>(internal::make_emphasis<Char>(ts.get_emphasis()), f);
-          internal::make_emphasis<Char>(ts.get_emphasis()), f);
   }
   if (ts.has_foreground()) {
     has_style = true;
@@ -565,8 +558,7 @@ typename std::enable_if<internal::is_string<String>::value>::type print(
  */
 template <typename String, typename... Args>
 typename std::enable_if<internal::is_string<String>::value>::type print(
-    const text_style &ts, const String &format_str,
+    const text_style &ts, const String &format_str, const Args &... args) {
-    const Args &... args) {
   return print(stdout, ts, format_str, args...);
 }
 

src/cpp/include/deps/spdlog/fmt/bundled/core.h

@@ -89,8 +89,8 @@
 #endif
 #endif
 
-#if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
+#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_GCC_VERSION >= 405 || \
-    FMT_GCC_VERSION >= 405 || FMT_MSC_VER >= 1800
+    FMT_MSC_VER >= 1800
 #define FMT_USE_EXPLICIT 1
 #define FMT_EXPLICIT explicit
 #else
@@ -147,12 +147,19 @@
 #if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
     FMT_MSC_VER >= 1900
 #define FMT_INLINE_NAMESPACE inline namespace
-#  define FMT_END_NAMESPACE }}
+#define FMT_END_NAMESPACE \
+  }                       \
+  }
 #else
 #define FMT_INLINE_NAMESPACE namespace
-#  define FMT_END_NAMESPACE } using namespace v5; }
+#define FMT_END_NAMESPACE \
+  }                       \
+  using namespace v5;     \
+  }
 #endif
-# define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
+#define FMT_BEGIN_NAMESPACE \
+  namespace fmt {           \
+  FMT_INLINE_NAMESPACE v5 {
 #endif
 
 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
@@ -199,8 +206,8 @@ struct result_of;
 template <typename F, typename... Args>
 struct result_of<F(Args...)> {
   // A workaround for gcc 4.4 that doesn't allow F to be a reference.
-  typedef typename std::result_of<
+  typedef typename std::result_of<typename std::remove_reference<F>::type(
-    typename std::remove_reference<F>::type(Args...)>::type type;
+      Args...)>::type type;
 };
 
 // Casts nonnegative integer to unsigned.
@@ -225,8 +232,10 @@ class basic_buffer {
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
   basic_buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
 
-  basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0)
+  basic_buffer(T *p = FMT_NULL, std::size_t sz = 0,
-    FMT_NOEXCEPT: ptr_(p), size_(sz), capacity_(cap) {}
+               std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p),
+                                                   size_(sz),
+                                                   capacity_(cap) {}
 
   /** Sets the buffer data and capacity. */
   void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
@@ -271,8 +280,7 @@ class basic_buffer {
 
   /** Reserves space to store at least *capacity* elements. */
   void reserve(std::size_t new_capacity) {
-    if (new_capacity > capacity_)
+    if (new_capacity > capacity_) grow(new_capacity);
-      grow(new_capacity);
   }
 
   void push_back(const T &value) {
@@ -360,7 +368,8 @@ class basic_string_view {
 
   /** Constructs a string reference object from a C string and a size. */
   FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
-    : data_(s), size_(count) {}
+      : data_(s),
+        size_(count) {}
 
   /**
     \rst
@@ -373,13 +382,14 @@ class basic_string_view {
 
   /** Constructs a string reference from a ``std::basic_string`` object. */
   template <typename Alloc>
-  FMT_CONSTEXPR basic_string_view(
+  FMT_CONSTEXPR basic_string_view(const std::basic_string<Char, Alloc> &s)
-      const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
+      FMT_NOEXCEPT : data_(s.data()),
-  : data_(s.data()), size_(s.size()) {}
+                     size_(s.size()) {}
 
 #ifdef FMT_STRING_VIEW
   FMT_CONSTEXPR basic_string_view(FMT_STRING_VIEW<Char> s) FMT_NOEXCEPT
-  : data_(s.data()), size_(s.size()) {}
+      : data_(s.data()),
+        size_(s.size()) {}
 #endif
 
   /** Returns a pointer to the string data. */
@@ -451,20 +461,26 @@ typedef basic_string_view<wchar_t> wstring_view;
   \endrst
  */
 template <typename Char>
-inline basic_string_view<Char>
+inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
-  to_string_view(basic_string_view<Char> s) { return s; }
+  return s;
+}
 
 template <typename Char>
-inline basic_string_view<Char>
+inline basic_string_view<Char> to_string_view(
-  to_string_view(const std::basic_string<Char> &s) { return s; }
+    const std::basic_string<Char> &s) {
+  return s;
+}
 
 template <typename Char>
-inline basic_string_view<Char> to_string_view(const Char *s) { return s; }
+inline basic_string_view<Char> to_string_view(const Char *s) {
+  return s;
+}
 
 #ifdef FMT_STRING_VIEW
 template <typename Char>
-inline basic_string_view<Char>
+inline basic_string_view<Char> to_string_view(FMT_STRING_VIEW<Char> s) {
-  to_string_view(FMT_STRING_VIEW<Char> s) { return s; }
+  return s;
+}
 #endif
 
 // A base class for compile-time strings. It is defined in the fmt namespace to
@@ -474,11 +490,12 @@ struct compile_string {};
 template <typename S>
 struct is_compile_string : std::is_base_of<compile_string, S> {};
 
-template <
+template <typename S, typename Enable = typename std::enable_if<
-  typename S,
+                          is_compile_string<S>::value>::type>
-  typename Enable = typename std::enable_if<is_compile_string<S>::value>::type>
+FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(
-FMT_CONSTEXPR basic_string_view<typename S::char_type>
+    const S &s) {
-  to_string_view(const S &s) { return s; }
+  return s;
+}
 
 template <typename Context>
 class basic_format_arg;
@@ -489,7 +506,8 @@ class basic_format_args;
 // A formatter for objects of type T.
 template <typename T, typename Char = char, typename Enable = void>
 struct formatter {
-  static_assert(internal::no_formatter_error<T>::value,
+  static_assert(
+      internal::no_formatter_error<T>::value,
       "don't know how to format the type, include fmt/ostream.h if it provides "
       "an operator<< that should be used");
 
@@ -501,19 +519,25 @@ struct formatter {
 };
 
 template <typename T, typename Char, typename Enable = void>
-struct convert_to_int: std::integral_constant<
+struct convert_to_int
-  bool, !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value> {};
+    : std::integral_constant<bool, !std::is_arithmetic<T>::value &&
+                                       std::is_convertible<T, int>::value> {};
 
 namespace internal {
 
-struct dummy_string_view { typedef void char_type; };
+struct dummy_string_view {
+  typedef void char_type;
+};
 dummy_string_view to_string_view(...);
 using fmt::v5::to_string_view;
 
 // Specifies whether S is a string type convertible to fmt::basic_string_view.
 template <typename S>
-struct is_string : std::integral_constant<bool, !std::is_same<
+struct is_string
-    dummy_string_view, decltype(to_string_view(declval<S>()))>::value> {};
+    : std::integral_constant<
+          bool, !std::is_same<dummy_string_view,
+                              decltype(to_string_view(declval<S>()))>::value> {
+};
 
 template <typename S>
 struct char_t {
@@ -528,13 +552,24 @@ template <typename T, typename Char>
 struct named_arg;
 
 enum type {
-  none_type, named_arg_type,
+  none_type,
+  named_arg_type,
   // Integer types should go first,
-  int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  bool_type,
+  char_type,
   last_integer_type = char_type,
   // followed by floating-point types.
-  double_type, long_double_type, last_numeric_type = long_double_type,
+  double_type,
-  cstring_type, string_type, pointer_type, custom_type
+  long_double_type,
+  last_numeric_type = long_double_type,
+  cstring_type,
+  string_type,
+  pointer_type,
+  custom_type
 };
 
 FMT_CONSTEXPR bool is_integral(type t) {
@@ -647,7 +682,9 @@ FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
 
 #define FMT_MAKE_VALUE_SAME(TAG, Type)                    \
   template <typename C>                                   \
-  FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { return val; }
+  FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { \
+    return val;                                           \
+  }
 
 FMT_MAKE_VALUE(bool_type, bool, int)
 FMT_MAKE_VALUE(int_type, short, int)
@@ -659,12 +696,12 @@ FMT_MAKE_VALUE_SAME(uint_type, unsigned)
 // either to int or to long long depending on its size.
 typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
     long_type;
-FMT_MAKE_VALUE(
+FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long,
-    (sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
+               long_type)
-typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
+typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned), unsigned,
-                         unsigned, unsigned long long>::type ulong_type;
+                         unsigned long long>::type ulong_type;
-FMT_MAKE_VALUE(
+FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type
-    (sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
+                                                          : ulong_long_type),
                unsigned long, ulong_type)
 
 FMT_MAKE_VALUE_SAME(long_long_type, long long)
@@ -674,14 +711,20 @@ FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
 
 // This doesn't use FMT_MAKE_VALUE because of ambiguity in gcc 4.4.
 template <typename C, typename Char>
-FMT_CONSTEXPR typename std::enable_if<
+FMT_CONSTEXPR
-  std::is_same<typename C::char_type, Char>::value,
+    typename std::enable_if<std::is_same<typename C::char_type, Char>::value,
-  init<C, int, char_type>>::type make_value(Char val) { return val; }
+                            init<C, int, char_type>>::type
+    make_value(Char val) {
+  return val;
+}
 
 template <typename C>
-FMT_CONSTEXPR typename std::enable_if<
+FMT_CONSTEXPR
-  !std::is_same<typename C::char_type, char>::value,
+    typename std::enable_if<!std::is_same<typename C::char_type, char>::value,
-  init<C, int, char_type>>::type make_value(char val) { return val; }
+                            init<C, int, char_type>>::type
+    make_value(char val) {
+  return val;
+}
 
 FMT_MAKE_VALUE(double_type, float, double)
 FMT_MAKE_VALUE_SAME(double_type, double)
@@ -722,17 +765,22 @@ typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
 }
 
 template <typename C, typename T>
-inline typename std::enable_if<
+inline
-    std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
+    typename std::enable_if<std::is_enum<T>::value &&
+                                convert_to_int<T, typename C::char_type>::value,
                             init<C, int, int_type>>::type
-  make_value(const T &val) { return static_cast<int>(val); }
+    make_value(const T &val) {
+  return static_cast<int>(val);
+}
 
 template <typename C, typename T, typename Char = typename C::char_type>
 inline typename std::enable_if<
     is_constructible<basic_string_view<Char>, T>::value &&
         !internal::is_string<T>::value,
     init<C, basic_string_view<Char>, string_type>>::type
-  make_value(const T &val) { return basic_string_view<Char>(val); }
+make_value(const T &val) {
+  return basic_string_view<Char>(val);
+}
 
 template <typename C, typename T, typename Char = typename C::char_type>
 inline typename std::enable_if<
@@ -743,11 +791,13 @@ inline typename std::enable_if<
     // Implicit conversion to std::string is not handled here because it's
     // unsafe: https://github.com/fmtlib/fmt/issues/729
     init<C, const T &, custom_type>>::type
-  make_value(const T &val) { return val; }
+make_value(const T &val) {
+  return val;
+}
 
 template <typename C, typename T>
-init<C, const void*, named_arg_type>
+init<C, const void *, named_arg_type> make_value(
-    make_value(const named_arg<T, typename C::char_type> &val) {
+    const named_arg<T, typename C::char_type> &val) {
   basic_format_arg<C> arg = make_arg<C>(val.value);
   std::memcpy(val.data, &arg, sizeof(arg));
   return static_cast<const void *>(&val);
@@ -759,8 +809,8 @@ FMT_CONSTEXPR11 typename std::enable_if<
     init<C, basic_string_view<typename C::char_type>, string_type>>::type
 make_value(const S &val) {
   // Handle adapted strings.
-  static_assert(std::is_same<
+  static_assert(std::is_same<typename C::char_type,
-    typename C::char_type, typename internal::char_t<S>::type>::value,
+                             typename internal::char_t<S>::type>::value,
                 "mismatch between char-types of context and argument");
   return to_string_view(val);
 }
@@ -782,8 +832,8 @@ class basic_format_arg {
   internal::type type_;
 
   template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_format_arg<ContextType>
+  friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
-    internal::make_arg(const T &value);
+      const T &value);
 
   template <typename Visitor, typename Ctx>
   friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
@@ -827,8 +877,8 @@ struct monostate {};
   \endrst
  */
 template <typename Visitor, typename Context>
-FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit_format_arg(
-    visit_format_arg(Visitor &&vis, const basic_format_arg<Context> &arg) {
+    Visitor &&vis, const basic_format_arg<Context> &arg) {
   typedef typename Context::char_type char_type;
   switch (arg.type_) {
     case internal::none_type:
@@ -855,8 +905,8 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
     case internal::cstring_type:
       return vis(arg.value_.string.value);
     case internal::string_type:
-    return vis(basic_string_view<char_type>(
+      return vis(basic_string_view<char_type>(arg.value_.string.value,
-                 arg.value_.string.value, arg.value_.string.size));
+                                              arg.value_.string.size));
     case internal::pointer_type:
       return vis(arg.value_.pointer);
     case internal::custom_type:
@@ -867,8 +917,8 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
 
 // DEPRECATED!
 template <typename Visitor, typename Context>
-FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(
-    visit(Visitor &&vis, const basic_format_arg<Context> &arg) {
+    Visitor &&vis, const basic_format_arg<Context> &arg) {
   return visit_format_arg(std::forward<Visitor>(vis), arg);
 }
 
@@ -884,8 +934,8 @@ class basic_parse_context : private ErrorHandler {
   typedef Char char_type;
   typedef typename basic_string_view<Char>::iterator iterator;
 
-  explicit FMT_CONSTEXPR basic_parse_context(
+  explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str,
-      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
+                                             ErrorHandler eh = ErrorHandler())
       : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
 
   // Returns an iterator to the beginning of the format string range being
@@ -961,8 +1011,7 @@ class arg_map {
   basic_format_arg<Context> find(basic_string_view<char_type> name) const {
     // The list is unsorted, so just return the first matching name.
     for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
-      if (it->name == name)
+      if (it->name == name) return it->arg;
-        return it->arg;
     }
     return {};
   }
@@ -1007,16 +1056,15 @@ class context_base {
   // Returns the argument with specified index.
   format_arg do_get_arg(unsigned arg_id) {
     format_arg arg = args_.get(arg_id);
-    if (!arg)
+    if (!arg) parse_context_.on_error("argument index out of range");
-      parse_context_.on_error("argument index out of range");
     return arg;
   }
 
   // Checks if manual indexing is used and returns the argument with
   // specified index.
   format_arg get_arg(unsigned arg_id) {
-    return this->parse_context().check_arg_id(arg_id) ?
+    return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id)
-      this->do_get_arg(arg_id) : format_arg();
+                                                      : format_arg();
   }
 
  public:
@@ -1048,7 +1096,9 @@ struct get_type {
 };
 
 template <typename Context>
-FMT_CONSTEXPR11 unsigned long long get_types() { return 0; }
+FMT_CONSTEXPR11 unsigned long long get_types() {
+  return 0;
+}
 
 template <typename Context, typename Arg, typename... Args>
 FMT_CONSTEXPR11 unsigned long long get_types() {
@@ -1064,8 +1114,8 @@ FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value) {
 }
 
 template <bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<IS_PACKED, value<Context>>::type
+inline typename std::enable_if<IS_PACKED, value<Context>>::type make_arg(
-    make_arg(const T &value) {
+    const T &value) {
   return make_value<Context>(value);
 }
 
@@ -1078,8 +1128,8 @@ inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
 
 // Formatting context.
 template <typename OutputIt, typename Char>
-class basic_format_context :
+class basic_format_context
-  public internal::context_base<
+    : public internal::context_base<
           OutputIt, basic_format_context<OutputIt, Char>, Char> {
  public:
   /** The character type for the output. */
@@ -1087,7 +1137,9 @@ class basic_format_context :
 
   // using formatter_type = formatter<T, char_type>;
   template <typename T>
-  struct formatter_type { typedef formatter<T, char_type> type; };
+  struct formatter_type {
+    typedef formatter<T, char_type> type;
+  };
 
  private:
   internal::arg_map<basic_format_context> map_;
@@ -1124,7 +1176,8 @@ class basic_format_context :
 template <typename Char>
 struct buffer_context {
   typedef basic_format_context<
-    std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
+      std::back_insert_iterator<internal::basic_buffer<Char>>, Char>
+      type;
 };
 typedef buffer_context<char>::type format_context;
 typedef buffer_context<wchar_t>::type wformat_context;
@@ -1144,8 +1197,8 @@ class format_arg_store {
   // Packed is a macro on MinGW so use IS_PACKED instead.
   static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
-  typedef typename std::conditional<IS_PACKED,
+  typedef typename std::conditional<IS_PACKED, internal::value<Context>,
-    internal::value<Context>, basic_format_arg<Context>>::type value_type;
+                                    basic_format_arg<Context>>::type value_type;
 
   // If the arguments are not packed, add one more element to mark the end.
   static const size_t DATA_SIZE =
@@ -1155,9 +1208,8 @@ class format_arg_store {
   friend class basic_format_args<Context>;
 
   static FMT_CONSTEXPR11 unsigned long long get_types() {
-    return IS_PACKED ?
+    return IS_PACKED ? internal::get_types<Context, Args...>()
-      internal::get_types<Context, Args...>() :
+                     : internal::is_unpacked_bit | NUM_ARGS;
-      internal::is_unpacked_bit | NUM_ARGS;
   }
 
  public:
@@ -1171,8 +1223,8 @@ class format_arg_store {
     (FMT_MSC_VER && FMT_MSC_VER <= 1800)
   // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
   format_arg_store(const Args &... args) {
-    value_type init[DATA_SIZE] =
+    value_type init[DATA_SIZE] = {
-      {internal::make_arg<IS_PACKED, Context>(args)...};
+        internal::make_arg<IS_PACKED, Context>(args)...};
     std::memcpy(data_, init, sizeof(init));
   }
 #else
@@ -1195,8 +1247,10 @@ const unsigned long long format_arg_store<Context, Args...>::TYPES =
   \endrst
  */
 template <typename Context = format_context, typename... Args>
-inline format_arg_store<Context, Args...>
+inline format_arg_store<Context, Args...> make_format_args(
-  make_format_args(const Args &... args) { return {args...}; }
+    const Args &... args) {
+  return {args...};
+}
 
 /** Formatting arguments. */
 template <typename Context>
@@ -1223,8 +1277,8 @@ class basic_format_args {
 
   typename internal::type type(unsigned index) const {
     unsigned shift = index * 4;
-    return static_cast<typename internal::type>(
+    return static_cast<typename internal::type>((types_ & (0xfull << shift)) >>
-      (types_ & (0xfull << shift)) >> shift);
+                                                shift);
   }
 
   friend class internal::arg_map<Context>;
@@ -1236,15 +1290,12 @@ class basic_format_args {
     format_arg arg;
     if (!is_packed()) {
       auto num_args = max_size();
-      if (index < num_args)
+      if (index < num_args) arg = args_[index];
-        arg = args_[index];
       return arg;
     }
-    if (index > internal::max_packed_args)
+    if (index > internal::max_packed_args) return arg;
-      return arg;
     arg.type_ = type(index);
-    if (arg.type_ == internal::none_type)
+    if (arg.type_ == internal::none_type) return arg;
-      return arg;
     internal::value<Context> &val = arg.value_;
     val = values_[index];
     return arg;
@@ -1310,13 +1361,13 @@ struct wformat_args : basic_format_args<wformat_context> {
 #if FMT_USE_ALIAS_TEMPLATES
 /** String's character type. */
 template <typename S>
-using char_t = FMT_ENABLE_IF_T(
+using char_t = FMT_ENABLE_IF_T(internal::is_string<S>::value,
-  internal::is_string<S>::value, typename internal::char_t<S>::type);
+                               typename internal::char_t<S>::type);
 #define FMT_CHAR(S) fmt::char_t<S>
 #else
 template <typename S>
-struct char_t : std::enable_if<
+struct char_t : std::enable_if<internal::is_string<S>::value,
-    internal::is_string<S>::value, typename internal::char_t<S>::type> {};
+                               typename internal::char_t<S>::type> {};
 #define FMT_CHAR(S) typename char_t<S>::type
 #endif
 
@@ -1326,8 +1377,8 @@ struct named_arg_base {
   basic_string_view<Char> name;
 
   // Serialized value<context>.
-  mutable char data[
+  mutable char
-    sizeof(basic_format_arg<typename buffer_context<Char>::type>)];
+      data[sizeof(basic_format_arg<typename buffer_context<Char>::type>)];
 
   named_arg_base(basic_string_view<Char> nm) : name(nm) {}
 
@@ -1351,16 +1402,16 @@ template <typename... Args, typename S>
 inline typename std::enable_if<!is_compile_string<S>::value>::type
 check_format_string(const S &) {}
 template <typename... Args, typename S>
-typename std::enable_if<is_compile_string<S>::value>::type
+typename std::enable_if<is_compile_string<S>::value>::type check_format_string(
-  check_format_string(S);
+    S);
 
 template <typename S, typename... Args>
-struct checked_args : format_arg_store<
+struct checked_args
-  typename buffer_context<FMT_CHAR(S)>::type, Args...> {
+    : format_arg_store<typename buffer_context<FMT_CHAR(S)>::type, Args...> {
   typedef typename buffer_context<FMT_CHAR(S)>::type context;
 
-  checked_args(const S &format_str, const Args &... args):
+  checked_args(const S &format_str, const Args &... args)
-    format_arg_store<context, Args...>(args...) {
+      : format_arg_store<context, Args...>(args...) {
     internal::check_format_string<Args...>(format_str);
   }
 
@@ -1376,7 +1427,7 @@ template <typename Char>
 typename buffer_context<Char>::type::iterator vformat_to(
     internal::basic_buffer<Char> &buf, basic_string_view<Char> format_str,
     basic_format_args<typename buffer_context<Char>::type> args);
-}
+}  // namespace internal
 
 /**
   \rst
@@ -1412,11 +1463,9 @@ struct is_contiguous<internal::basic_buffer<Char> >: std::true_type {};
 
 /** Formats a string and writes the output to ``out``. */
 template <typename Container, typename S>
-typename std::enable_if<
+typename std::enable_if<is_contiguous<Container>::value,
-    is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
+                        std::back_insert_iterator<Container>>::type
-  vformat_to(
+vformat_to(std::back_insert_iterator<Container> out, const S &format_str,
-    std::back_insert_iterator<Container> out,
-    const S &format_str,
            basic_format_args<typename buffer_context<FMT_CHAR(S)>::type> args) {
   internal::container_buffer<Container> buf(internal::get_container(out));
   internal::vformat_to(buf, to_string_view(format_str), args);
@@ -1424,8 +1473,8 @@ typename std::enable_if<
 }
 
 template <typename Container, typename S, typename... Args>
-inline typename std::enable_if<
+inline typename std::enable_if<is_contiguous<Container>::value &&
-  is_contiguous<Container>::value && internal::is_string<S>::value,
+                                   internal::is_string<S>::value,
                                std::back_insert_iterator<Container>>::type
 format_to(std::back_insert_iterator<Container> out, const S &format_str,
           const Args &... args) {
@@ -1451,8 +1500,8 @@ inline std::basic_string<Char> vformat(
   \endrst
 */
 template <typename S, typename... Args>
-inline std::basic_string<FMT_CHAR(S)> format(
+inline std::basic_string<FMT_CHAR(S)> format(const S &format_str,
-    const S &format_str, const Args &... args) {
+                                             const Args &... args) {
   return internal::vformat(
       to_string_view(format_str),
       *internal::checked_args<S, Args...>(format_str, args...));

src/cpp/include/deps/spdlog/fmt/bundled/format-inl.h

@@ -8,8 +8,6 @@
 #ifndef FMT_FORMAT_INL_H_
 #define FMT_FORMAT_INL_H_
 
-#include "format.h"
-
 #include <string.h>
 
 #include <cctype>
@@ -19,6 +17,8 @@
 #include <cstdarg>
 #include <cstddef>  // for std::ptrdiff_t
 #include <cstring>  // for std::memmove
+
+#include "format.h"
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
 #include <locale>
 #endif
@@ -96,8 +96,8 @@ typedef void (*FormatFunc)(internal::buffer &, int, string_view);
 //   ERANGE - buffer is not large enough to store the error message
 //   other  - failure
 // Buffer should be at least of size 1.
-int safe_strerror(
+int safe_strerror(int error_code, char *&buffer,
-    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
+                  std::size_t buffer_size) FMT_NOEXCEPT {
   FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
 
   class dispatcher {
@@ -132,8 +132,8 @@ int safe_strerror(
     // Fallback to strerror_s when strerror_r is not available.
     int fallback(int result) {
       // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
+      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
-            ERANGE : result;
+                                                                : result;
     }
 
 #if !FMT_MSC_VER
@@ -149,9 +149,7 @@ int safe_strerror(
     dispatcher(int err_code, char *&buf, std::size_t buf_size)
         : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
 
-    int run() {
+    int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
-      return handle(strerror_r(error_code_, buffer_, buffer_size_));
-    }
   };
   return dispatcher(error_code, buffer, buffer_size).run();
 }
@@ -198,8 +196,7 @@ FMT_FUNC size_t internal::count_code_points(basic_string_view<char8_t> s) {
   const char8_t *data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80)
+    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
-      ++num_code_points;
   }
   return num_code_points;
 }
@@ -220,10 +217,10 @@ Locale locale_ref::get() const {
 
 template <typename Char>
 FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char> >(
+  return std::use_facet<std::numpunct<Char> >(loc.get<std::locale>())
-    loc.get<std::locale>()).thousands_sep();
+      .thousands_sep();
-}
 }
+}  // namespace internal
 #else
 template <typename Char>
 FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
@@ -231,8 +228,8 @@ FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
 }
 #endif
 
-FMT_FUNC void system_error::init(
+FMT_FUNC void system_error::init(int err_code, string_view format_str,
-    int err_code, string_view format_str, format_args args) {
+                                 format_args args) {
   error_code_ = err_code;
   memory_buffer buffer;
   format_system_error(buffer, err_code, vformat(format_str, args));
@@ -242,20 +239,19 @@ FMT_FUNC void system_error::init(
 
 namespace internal {
 template <typename T>
-int char_traits<char>::format_float(
+int char_traits<char>::format_float(char *buf, std::size_t size,
-    char *buf, std::size_t size, const char *format, int precision, T value) {
+                                    const char *format, int precision,
-  return precision < 0 ?
+                                    T value) {
-      FMT_SNPRINTF(buf, size, format, value) :
+  return precision < 0 ? FMT_SNPRINTF(buf, size, format, value)
-      FMT_SNPRINTF(buf, size, format, precision, value);
+                       : FMT_SNPRINTF(buf, size, format, precision, value);
 }
 
 template <typename T>
-int char_traits<wchar_t>::format_float(
+int char_traits<wchar_t>::format_float(wchar_t *buf, std::size_t size,
-    wchar_t *buf, std::size_t size, const wchar_t *format, int precision,
+                                       const wchar_t *format, int precision,
                                        T value) {
-  return precision < 0 ?
+  return precision < 0 ? FMT_SWPRINTF(buf, size, format, value)
-      FMT_SWPRINTF(buf, size, format, value) :
+                       : FMT_SWPRINTF(buf, size, format, precision, value);
-      FMT_SWPRINTF(buf, size, format, precision, value);
 }
 
 template <typename T>
@@ -267,33 +263,21 @@ const char basic_data<T>::DIGITS[] =
     "8081828384858687888990919293949596979899";
 
 #define FMT_POWERS_OF_10(factor)                                             \
-  factor * 10, \
+  factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, \
-  factor * 100, \
+      factor * 1000000, factor * 10000000, factor * 100000000,               \
-  factor * 1000, \
-  factor * 10000, \
-  factor * 100000, \
-  factor * 1000000, \
-  factor * 10000000, \
-  factor * 100000000, \
       factor * 1000000000
 
 template <typename T>
-const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
+const uint32_t basic_data<T>::POWERS_OF_10_32[] = {1, FMT_POWERS_OF_10(1)};
-  1, FMT_POWERS_OF_10(1)
-};
 
 template <typename T>
-const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {
+const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {0,
-  0, FMT_POWERS_OF_10(1)
+                                                           FMT_POWERS_OF_10(1)};
-};
 
 template <typename T>
 const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = {
-  0,
+    0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull),
-  FMT_POWERS_OF_10(1),
+    10000000000000000000ull};
-  FMT_POWERS_OF_10(1000000000ull),
-  10000000000000000000ull
-};
 
 // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
 // These are generated by support/compute-powers.py.
@@ -341,13 +325,16 @@ const int16_t basic_data<T>::POW10_EXPONENTS[] = {
     -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
     242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
     534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
+    827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-};
 
-template <typename T> const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
+template <typename T>
-template <typename T> const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;";
+const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
-template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template <typename T>
-template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;";
+template <typename T>
+const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template <typename T>
+const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
 
 // A handmade floating-point number f * pow(2, e).
 class fp {
@@ -416,8 +403,8 @@ class fp {
   // (lower) or successor (upper). The upper boundary is normalized and lower
   // has the same exponent but may be not normalized.
   void compute_boundaries(fp &lower, fp &upper) const {
-    lower = f == implicit_bit ?
+    lower =
-          fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
+        f == implicit_bit ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
     upper = fp((f << 1) + 1, e - 1);
     upper.normalize<1>();  // 1 is to account for the exponent shift above.
     lower.f <<= lower.e - upper.e;
@@ -432,7 +419,8 @@ inline fp operator-(fp x, fp y) {
 }
 
 // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
-// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be normalized.
+// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be
+// normalized.
 FMT_API fp operator*(fp x, fp y);
 
 // Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
@@ -452,8 +440,8 @@ FMT_FUNC fp operator*(fp x, fp y) {
 
 FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
   const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-  int index = static_cast<int>(std::ceil(
+  int index = static_cast<int>(
-        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
+      std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
   // Decimal exponent of the first (smallest) cached power of 10.
   const int first_dec_exp = -348;
   // Difference between 2 consecutive decimal exponents in cached powers of 10.
@@ -463,10 +451,11 @@ FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
   return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
 }
 
-FMT_FUNC bool grisu2_round(
+FMT_FUNC bool grisu2_round(char *buf, int &size, int max_digits, uint64_t delta,
-    char *buf, int &size, int max_digits, uint64_t delta,
+                           uint64_t remainder, uint64_t exp, uint64_t diff,
-    uint64_t remainder, uint64_t exp, uint64_t diff, int &exp10) {
+                           int &exp10) {
-  while (remainder < diff && delta - remainder >= exp &&
+  while (
+      remainder < diff && delta - remainder >= exp &&
       (remainder + exp < diff || diff - remainder > remainder + exp - diff)) {
     --buf[size - 1];
     remainder += exp;
@@ -474,44 +463,72 @@ FMT_FUNC bool grisu2_round(
   if (size > max_digits) {
     --size;
     ++exp10;
-    if (buf[size] >= '5')
+    if (buf[size] >= '5') return false;
-      return false;
   }
   return true;
 }
 
 // Generates output using Grisu2 digit-gen algorithm.
-FMT_FUNC bool grisu2_gen_digits(
+FMT_FUNC bool grisu2_gen_digits(char *buf, int &size, uint32_t hi, uint64_t lo,
-    char *buf, int &size, uint32_t hi, uint64_t lo, int &exp,
+                                int &exp, uint64_t delta, const fp &one,
-    uint64_t delta, const fp &one, const fp &diff, int max_digits) {
+                                const fp &diff, int max_digits) {
   // Generate digits for the most significant part (hi).
   while (exp > 0) {
     uint32_t digit = 0;
     // This optimization by miloyip reduces the number of integer divisions by
     // one per iteration.
     switch (exp) {
-    case 10: digit = hi / 1000000000; hi %= 1000000000; break;
+      case 10:
-    case  9: digit = hi /  100000000; hi %=  100000000; break;
+        digit = hi / 1000000000;
-    case  8: digit = hi /   10000000; hi %=   10000000; break;
+        hi %= 1000000000;
-    case  7: digit = hi /    1000000; hi %=    1000000; break;
+        break;
-    case  6: digit = hi /     100000; hi %=     100000; break;
+      case 9:
-    case  5: digit = hi /      10000; hi %=      10000; break;
+        digit = hi / 100000000;
-    case  4: digit = hi /       1000; hi %=       1000; break;
+        hi %= 100000000;
-    case  3: digit = hi /        100; hi %=        100; break;
+        break;
-    case  2: digit = hi /         10; hi %=         10; break;
+      case 8:
-    case  1: digit = hi;              hi =           0; break;
+        digit = hi / 10000000;
+        hi %= 10000000;
+        break;
+      case 7:
+        digit = hi / 1000000;
+        hi %= 1000000;
+        break;
+      case 6:
+        digit = hi / 100000;
+        hi %= 100000;
+        break;
+      case 5:
+        digit = hi / 10000;
+        hi %= 10000;
+        break;
+      case 4:
+        digit = hi / 1000;
+        hi %= 1000;
+        break;
+      case 3:
+        digit = hi / 100;
+        hi %= 100;
+        break;
+      case 2:
+        digit = hi / 10;
+        hi %= 10;
+        break;
+      case 1:
+        digit = hi;
+        hi = 0;
+        break;
       default:
         FMT_ASSERT(false, "invalid number of digits");
     }
-    if (digit != 0 || size != 0)
+    if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
-      buf[size++] = static_cast<char>('0' + digit);
     --exp;
     uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo;
     if (remainder <= delta || size > max_digits) {
       return grisu2_round(
           buf, size, max_digits, delta, remainder,
-            static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e,
+          static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e, diff.f,
-            diff.f, exp);
+          exp);
     }
   }
   // Generate digits for the least significant part (lo).
@@ -519,8 +536,7 @@ FMT_FUNC bool grisu2_gen_digits(
     lo *= 10;
     delta *= 10;
     char digit = static_cast<char>(lo >> -one.e);
-    if (digit != 0 || size != 0)
+    if (digit != 0 || size != 0) buf[size++] = static_cast<char>('0' + digit);
-      buf[size++] = static_cast<char>('0' + digit);
     lo &= one.f - 1;
     --exp;
     if (lo < delta || size > max_digits) {
@@ -616,14 +632,13 @@ struct fill {
 
 // The number is given as v = f * pow(10, exp), where f has size digits.
 template <typename Handler>
-FMT_FUNC void grisu2_prettify(const gen_digits_params &params,
+FMT_FUNC void grisu2_prettify(const gen_digits_params &params, int size,
-                              int size, int exp, Handler &&handler) {
+                              int exp, Handler &&handler) {
   if (!params.fixed) {
     // Insert a decimal point after the first digit and add an exponent.
     handler.insert(1, '.');
     exp += size - 1;
-    if (size < params.num_digits)
+    if (size < params.num_digits) handler.append(params.num_digits - size, '0');
-      handler.append(params.num_digits - size, '0');
     handler.append(params.upper ? 'E' : 'e');
     write_exponent(exp, handler);
     return;
@@ -660,7 +675,9 @@ struct char_counter {
   ptrdiff_t size;
 
   template <typename F>
-  void insert(ptrdiff_t, ptrdiff_t n, F) { size += n; }
+  void insert(ptrdiff_t, ptrdiff_t n, F) {
+    size += n;
+  }
   void insert(ptrdiff_t, char) { ++size; }
   void append(ptrdiff_t n, char) { size += n; }
   void append(char) { ++size; }
@@ -678,7 +695,8 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
     case 'G':
       params.upper = true;
       FMT_FALLTHROUGH
-  case '\0': case 'g':
+    case '\0':
+    case 'g':
       params.trailing_zeros = (specs.flags & HASH_FLAG) != 0;
       if (-4 <= exp && exp < num_digits + 1) {
         params.fixed = true;
@@ -693,8 +711,7 @@ FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
       params.fixed = true;
       params.trailing_zeros = true;
       int adjusted_min_digits = num_digits + exp;
-    if (adjusted_min_digits > 0)
+      if (adjusted_min_digits > 0) num_digits = adjusted_min_digits;
-      num_digits = adjusted_min_digits;
       break;
     }
     case 'E':
@@ -771,14 +788,12 @@ void sprintf_format(Double value, internal::buffer &buf,
   char format[MAX_FORMAT_SIZE];
   char *format_ptr = format;
   *format_ptr++ = '%';
-  if (spec.has(HASH_FLAG))
+  if (spec.has(HASH_FLAG)) *format_ptr++ = '#';
-    *format_ptr++ = '#';
   if (spec.precision >= 0) {
     *format_ptr++ = '.';
     *format_ptr++ = '*';
   }
-  if (std::is_same<Double, long double>::value)
+  if (std::is_same<Double, long double>::value) *format_ptr++ = 'L';
-    *format_ptr++ = 'L';
   *format_ptr++ = spec.type;
   *format_ptr = '\0';
 
@@ -819,15 +834,13 @@ FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
     return;
   }
 
-  int length = MultiByteToWideChar(
+  int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(),
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
+                                   s_size, FMT_NULL, 0);
-  if (length == 0)
+  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
-    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_.resize(length + 1);
-  length = MultiByteToWideChar(
+  length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size,
-    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
+                               &buffer_[0], length);
-  if (length == 0)
+  if (length == 0) FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
-    FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_[length] = 0;
 }
 
@@ -839,8 +852,7 @@ FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
 }
 
 FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-  if (s.size() > INT_MAX)
+  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
-    return ERROR_INVALID_PARAMETER;
   int s_size = static_cast<int>(s.size());
   if (s_size == 0) {
     // WideCharToMultiByte does not support zero length, handle separately.
@@ -849,21 +861,19 @@ FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
     return 0;
   }
 
-  int length = WideCharToMultiByte(
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0,
-        CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
+                                   FMT_NULL, FMT_NULL);
-  if (length == 0)
+  if (length == 0) return GetLastError();
-    return GetLastError();
   buffer_.resize(length + 1);
-  length = WideCharToMultiByte(
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
-    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
+                               length, FMT_NULL, FMT_NULL);
-  if (length == 0)
+  if (length == 0) return GetLastError();
-    return GetLastError();
   buffer_[length] = 0;
   return 0;
 }
 
-FMT_FUNC void windows_error::init(
+FMT_FUNC void windows_error::init(int err_code, string_view format_str,
-    int err_code, string_view format_str, format_args args) {
+                                  format_args args) {
   error_code_ = err_code;
   memory_buffer buffer;
   internal::format_windows_error(buffer, err_code, vformat(format_str, args));
@@ -871,17 +881,18 @@ FMT_FUNC void windows_error::init(
   base = std::runtime_error(to_string(buffer));
 }
 
-FMT_FUNC void internal::format_windows_error(
+FMT_FUNC void internal::format_windows_error(internal::buffer &out,
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+                                             int error_code,
+                                             string_view message) FMT_NOEXCEPT {
   FMT_TRY {
     wmemory_buffer buf;
     buf.resize(inline_buffer_size);
     for (;;) {
       wchar_t *system_message = &buf[0];
       int result = FormatMessageW(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL,
-          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
-          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+          static_cast<uint32_t>(buf.size()), FMT_NULL);
       if (result != 0) {
         utf16_to_utf8 utf8_message;
         if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
@@ -897,14 +908,15 @@ FMT_FUNC void internal::format_windows_error(
         break;  // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
-  } FMT_CATCH(...) {}
+  }
+  FMT_CATCH(...) {}
   format_error_code(out, error_code, message);
 }
 
 #endif  // FMT_USE_WINDOWS_H
 
-FMT_FUNC void format_system_error(
+FMT_FUNC void format_system_error(internal::buffer &out, int error_code,
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+                                  string_view message) FMT_NOEXCEPT {
   FMT_TRY {
     memory_buffer buf;
     buf.resize(inline_buffer_size);
@@ -922,7 +934,8 @@ FMT_FUNC void format_system_error(
         break;  // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
-  } FMT_CATCH(...) {}
+  }
+  FMT_CATCH(...) {}
   format_error_code(out, error_code, message);
 }
 
@@ -930,14 +943,14 @@ FMT_FUNC void internal::error_handler::on_error(const char *message) {
   FMT_THROW(format_error(message));
 }
 
-FMT_FUNC void report_system_error(
+FMT_FUNC void report_system_error(int error_code,
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+                                  fmt::string_view message) FMT_NOEXCEPT {
   report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(
+FMT_FUNC void report_windows_error(int error_code,
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+                                   fmt::string_view message) FMT_NOEXCEPT {
   report_error(internal::format_windows_error, error_code, message);
 }
 #endif

src/cpp/include/deps/spdlog/fmt/bundled/locale.h

@@ -8,9 +8,10 @@
 #ifndef FMT_LOCALE_H_
 #define FMT_LOCALE_H_
 
-#include "format.h"
 #include <locale>
 
+#include "format.h"
+
 FMT_BEGIN_NAMESPACE
 
 namespace internal {
@@ -20,8 +21,8 @@ typename buffer_context<Char>::type::iterator vformat_to(
     basic_string_view<Char> format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
   typedef back_insert_range<basic_buffer<Char>> range;
-  return vformat_to<arg_formatter<range>>(
+  return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args,
-    buf, to_string_view(format_str), args, internal::locale_ref(loc));
+                                          internal::locale_ref(loc));
 }
 
 template <typename Char>
@@ -32,7 +33,7 @@ std::basic_string<Char> vformat(
   internal::vformat_to(loc, buffer, format_str, args);
   return fmt::to_string(buffer);
 }
-}
+}  // namespace internal
 
 template <typename S, typename Char = FMT_CHAR(S)>
 inline std::basic_string<Char> vformat(
@@ -42,8 +43,9 @@ inline std::basic_string<Char> vformat(
 }
 
 template <typename S, typename... Args>
-inline std::basic_string<FMT_CHAR(S)> format(
+inline std::basic_string<FMT_CHAR(S)> format(const std::locale &loc,
-    const std::locale &loc, const S &format_str, const Args &... args) {
+                                             const S &format_str,
+                                             const Args &... args) {
   return internal::vformat(
       loc, to_string_view(format_str),
       *internal::checked_args<S, Args...>(format_str, args...));
@@ -60,9 +62,10 @@ inline typename std::enable_if<internal::is_output_iterator<OutputIt>::value,
 }
 
 template <typename OutputIt, typename S, typename... Args>
-inline typename std::enable_if<
+inline
-    internal::is_string<S>::value &&
+    typename std::enable_if<internal::is_string<S>::value &&
-    internal::is_output_iterator<OutputIt>::value, OutputIt>::type
+                                internal::is_output_iterator<OutputIt>::value,
+                            OutputIt>::type
     format_to(OutputIt out, const std::locale &loc, const S &format_str,
               const Args &... args) {
   internal::check_format_string<Args...>(format_str);

src/cpp/include/deps/spdlog/fmt/bundled/ostream.h

@@ -8,9 +8,10 @@
 #ifndef FMT_OSTREAM_H_
 #define FMT_OSTREAM_H_
 
-#include "format.h"
 #include <ostream>
 
+#include "format.h"
+
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
@@ -53,14 +54,16 @@ struct test_stream : std::basic_ostream<Char> {
   void operator<<(null);
 };
 
-// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
+// Checks if T has a user-defined operator<< (e.g. not a member of
+// std::ostream).
 template <typename T, typename Char>
 class is_streamable {
  private:
   template <typename U>
-  static decltype(
+  static decltype(internal::declval<test_stream<Char> &>()
-    internal::declval<test_stream<Char>&>()
+                      << internal::declval<U>(),
-      << internal::declval<U>(), std::true_type()) test(int);
+                  std::true_type())
+  test(int);
 
   template <typename>
   static std::false_type test(...);
@@ -101,8 +104,7 @@ void format_value(basic_buffer<Char> &buffer, const T &value) {
 // function (not a member of std::ostream).
 template <typename T, typename Char>
 struct convert_to_int<T, Char, void> {
-  static const bool value =
+  static const bool value = convert_to_int<T, Char, int>::value &&
-    convert_to_int<T, Char, int>::value &&
                             !internal::is_streamable<T, Char>::value;
 };
 
@@ -111,10 +113,9 @@ template <typename T, typename Char>
 struct formatter<T, Char,
                  typename std::enable_if<
                      internal::is_streamable<T, Char>::value &&
-      !internal::format_type<
+                     !internal::format_type<typename buffer_context<Char>::type,
-        typename buffer_context<Char>::type, T>::value>::type>
+                                            T>::value>::type>
     : formatter<basic_string_view<Char>, Char> {
-
   template <typename Context>
   auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
     basic_memory_buffer<Char> buffer;
@@ -125,8 +126,8 @@ struct formatter<T, Char,
 };
 
 template <typename Char>
-inline void vprint(std::basic_ostream<Char> &os,
+inline void vprint(
-                   basic_string_view<Char> format_str,
+    std::basic_ostream<Char> &os, basic_string_view<Char> format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
@@ -142,8 +143,8 @@ inline void vprint(std::basic_ostream<Char> &os,
   \endrst
  */
 template <typename S, typename... Args>
-inline typename std::enable_if<internal::is_string<S>::value>::type
+inline typename std::enable_if<internal::is_string<S>::value>::type print(
-print(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
+    std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
     const Args &... args) {
   internal::checked_args<S, Args...> ca(format_str, args...);
   vprint(os, to_string_view(format_str), *ca);

src/cpp/include/deps/spdlog/fmt/bundled/posix.h

@@ -143,7 +143,6 @@ class buffered_file {
   buffered_file(const buffered_file &) = delete;
   void operator=(const buffered_file &) = delete;
 
-
  public:
   buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
     other.file_ = FMT_NULL;
@@ -211,9 +210,7 @@ class file {
   void operator=(const file &) = delete;
 
  public:
-  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
+  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
-    other.fd_ = -1;
-  }
 
   file &operator=(file &&other) {
     close();
@@ -284,9 +281,7 @@ class Locale {
     return _create_locale(category_mask, locale);
   }
 
-  static void freelocale(locale_t locale) {
+  static void freelocale(locale_t locale) { _free_locale(locale); }
-    _free_locale(locale);
-  }
 
   static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
     return _strtod_l(nptr, endptr, locale);
@@ -302,8 +297,7 @@ class Locale {
   typedef locale_t Type;
 
   Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
-    if (!locale_)
+    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
-      FMT_THROW(system_error(errno, "cannot create locale"));
   }
   ~Locale() { freelocale(locale_); }
 

src/cpp/include/deps/spdlog/fmt/bundled/printf.h

@@ -43,9 +43,7 @@ class null_terminating_iterator {
     return *this;
   }
 
-  FMT_CONSTEXPR Char operator*() const {
+  FMT_CONSTEXPR Char operator*() const { return ptr_ != end_ ? *ptr_ : Char(); }
-    return ptr_ != end_ ? *ptr_ : Char();
-  }
 
   FMT_CONSTEXPR null_terminating_iterator operator++() {
     ++ptr_;
@@ -76,8 +74,8 @@ class null_terminating_iterator {
     return *this;
   }
 
-  FMT_CONSTEXPR difference_type operator-(
+  FMT_CONSTEXPR difference_type
-      null_terminating_iterator other) const {
+  operator-(null_terminating_iterator other) const {
     return ptr_ - other.ptr_;
   }
 
@@ -101,7 +99,9 @@ class null_terminating_iterator {
 };
 
 template <typename T>
-FMT_CONSTEXPR const T *pointer_from(const T *p) { return p; }
+FMT_CONSTEXPR const T *pointer_from(const T *p) {
+  return p;
+}
 
 template <typename Char>
 FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) {
@@ -135,8 +135,7 @@ FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
     ++next;
     it = next;
   } while ('0' <= *it && *it <= '9');
-  if (value > max_int)
+  if (value > max_int) eh.on_error("number is too big");
-    eh.on_error("number is too big");
   return value;
 }
 
@@ -165,15 +164,16 @@ struct int_checker<true> {
 class printf_precision_handler : public function<int> {
  public:
   template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, int>::type
+  typename std::enable_if<std::is_integral<T>::value, int>::type operator()(
-      operator()(T value) {
+      T value) {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
       FMT_THROW(format_error("number is too big"));
     return static_cast<int>(value);
   }
 
   template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
+  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(
+      T) {
     FMT_THROW(format_error("precision is not integer"));
     return 0;
   }
@@ -183,12 +183,16 @@ class printf_precision_handler: public function<int> {
 class is_zero_int : public function<bool> {
  public:
   template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, bool>::type
+  typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(
-      operator()(T value) { return value == 0; }
+      T value) {
+    return value == 0;
+  }
 
   template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, bool>::type
+  typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(
-      operator()(T) { return false; }
+      T) {
+    return false;
+  }
 };
 
 template <typename T>
@@ -212,16 +216,15 @@ class arg_converter: public function<void> {
       : arg_(arg), type_(type) {}
 
   void operator()(bool value) {
-    if (type_ != 's')
+    if (type_ != 's') operator()<bool>(value);
-      operator()<bool>(value);
   }
 
   template <typename U>
-  typename std::enable_if<std::is_integral<U>::value>::type
+  typename std::enable_if<std::is_integral<U>::value>::type operator()(
-      operator()(U value) {
+      U value) {
     bool is_signed = type_ == 'd' || type_ == 'i';
-    typedef typename std::conditional<
+    typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type
-        std::is_same<T, void>::value, U, T>::type TargetType;
+        TargetType;
     if (const_check(sizeof(TargetType) <= sizeof(int))) {
       // Extra casts are used to silence warnings.
       if (is_signed) {
@@ -270,8 +273,8 @@ class char_converter: public function<void> {
   explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
   template <typename T>
-  typename std::enable_if<std::is_integral<T>::value>::type
+  typename std::enable_if<std::is_integral<T>::value>::type operator()(
-      operator()(T value) {
+      T value) {
     typedef typename Context::char_type Char;
     arg_ = internal::make_arg<Context>(static_cast<Char>(value));
   }
@@ -304,8 +307,7 @@ class printf_width_handler: public function<unsigned> {
       width = 0 - width;
     }
     unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max)
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
-      FMT_THROW(format_error("number is too big"));
     return static_cast<unsigned>(width);
   }
 
@@ -329,10 +331,9 @@ using internal::printf;  // For printing into memory_buffer.
 template <typename Range>
 class printf_arg_formatter;
 
-template <
+template <typename OutputIt, typename Char,
-    typename OutputIt, typename Char,
+          typename ArgFormatter = printf_arg_formatter<
-    typename ArgFormatter =
+              back_insert_range<internal::basic_buffer<Char>>>>
-      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
 class basic_printf_context;
 
 /**
@@ -341,8 +342,8 @@ class basic_printf_context;
   \endrst
  */
 template <typename Range>
-class printf_arg_formatter:
+class printf_arg_formatter
-  public internal::function<
+    : public internal::function<
           typename internal::arg_formatter_base<Range>::iterator>,
       public internal::arg_formatter_base<Range> {
  private:
@@ -375,8 +376,8 @@ class printf_arg_formatter:
    */
   printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
                        format_specs &spec, context_type &ctx)
-    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), &spec,
+      : base(back_insert_range<internal::basic_buffer<char_type>>(buffer),
-           ctx.locale()),
+             &spec, ctx.locale()),
         context_(ctx) {}
 
   template <typename T>
@@ -386,8 +387,7 @@ class printf_arg_formatter:
     // use std::is_same instead.
     if (std::is_same<T, bool>::value) {
       format_specs &fmt_spec = *this->spec();
-      if (fmt_spec.type != 's')
+      if (fmt_spec.type != 's') return base::operator()(value ? 1 : 0);
-        return base::operator()(value ? 1 : 0);
       fmt_spec.type = 0;
       this->write(value != 0);
     } else if (std::is_same<T, char_type>::value) {
@@ -435,14 +435,11 @@ class printf_arg_formatter:
     return base::operator()(value);
   }
 
-  iterator operator()(monostate value) {
+  iterator operator()(monostate value) { return base::operator()(value); }
-    return base::operator()(value);
-  }
 
   /** Formats a pointer. */
   iterator operator()(const void *value) {
-    if (value)
+    if (value) return base::operator()(value);
-      return base::operator()(value);
     this->spec()->type = 0;
     write_null_pointer(char_type());
     return this->out();
@@ -458,7 +455,9 @@ class printf_arg_formatter:
 template <typename T>
 struct printf_formatter {
   template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 
   template <typename FormatContext>
   auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
@@ -479,7 +478,9 @@ class basic_printf_context :
   typedef Char char_type;
 
   template <typename T>
-  struct formatter_type { typedef printf_formatter<T> type; };
+  struct formatter_type {
+    typedef printf_formatter<T> type;
+  };
 
  private:
   typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
@@ -492,8 +493,7 @@ class basic_printf_context :
   // Returns the argument with specified index or, if arg_index is equal
   // to the maximum unsigned value, the next argument.
   format_arg get_arg(
-      iterator it,
+      iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
 
   // Parses argument index, flags and width and returns the argument index.
   unsigned parse_header(iterator &it, format_specs &spec);
@@ -510,17 +510,17 @@ class basic_printf_context :
                        basic_format_args<basic_printf_context> args)
       : base(out, format_str, args) {}
 
-  using base::parse_context;
-  using base::out;
   using base::advance_to;
+  using base::out;
+  using base::parse_context;
 
   /** Formats stored arguments and writes the output to the range. */
   void format();
 };
 
 template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::parse_flags(
+void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec,
-    format_specs &spec, iterator &it) {
+                                                           iterator &it) {
   for (;;) {
     switch (*it++) {
       case '-':
@@ -547,8 +547,8 @@ void basic_printf_context<OutputIt, Char, AF>::parse_flags(
 
 template <typename OutputIt, typename Char, typename AF>
 typename basic_printf_context<OutputIt, Char, AF>::format_arg
-  basic_printf_context<OutputIt, Char, AF>::get_arg(
+basic_printf_context<OutputIt, Char, AF>::get_arg(iterator it,
-    iterator it, unsigned arg_index) {
+                                                  unsigned arg_index) {
   (void)it;
   if (arg_index == std::numeric_limits<unsigned>::max())
     return this->do_get_arg(this->parse_context().next_arg_id());
@@ -569,8 +569,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
       ++it;
       arg_index = value;
     } else {
-      if (c == '0')
+      if (c == '0') spec.fill_ = '0';
-        spec.fill_ = '0';
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
@@ -631,7 +630,8 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
 
     format_arg arg = get_arg(it, arg_index);
     if (spec.has(HASH_FLAG) && visit_format_arg(internal::is_zero_int(), arg))
-      spec.flags = static_cast<uint_least8_t>(spec.flags & (~internal::to_unsigned<int>(HASH_FLAG)));
+      spec.flags = static_cast<uint_least8_t>(
+          spec.flags & (~internal::to_unsigned<int>(HASH_FLAG)));
     if (spec.fill_ == '0') {
       if (arg.is_arithmetic())
         spec.align_ = ALIGN_NUMERIC;
@@ -673,19 +673,19 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
     }
 
     // Parse type.
-    if (!*it)
+    if (!*it) FMT_THROW(format_error("invalid format string"));
-      FMT_THROW(format_error("invalid format string"));
     spec.type = static_cast<char>(*it++);
     if (arg.is_integral()) {
       // Normalize type.
       switch (spec.type) {
-      case 'i': case 'u':
+        case 'i':
+        case 'u':
           spec.type = 'd';
           break;
         case 'c':
           // TODO: handle wchar_t better?
-        visit_format_arg(
+          visit_format_arg(internal::char_converter<basic_printf_context>(arg),
-              internal::char_converter<basic_printf_context>(arg), arg);
+                           arg);
           break;
       }
     }
@@ -700,8 +700,9 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
 
 template <typename Buffer>
 struct basic_printf_context_t {
-  typedef basic_printf_context<
+  typedef basic_printf_context<std::back_insert_iterator<Buffer>,
-    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+                               typename Buffer::value_type>
+      type;
 };
 
 typedef basic_printf_context_t<internal::buffer>::type printf_context;
@@ -717,8 +718,10 @@ typedef basic_format_args<wprintf_context> wprintf_args;
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<printf_context, Args...>
+inline format_arg_store<printf_context, Args...> make_printf_args(
-  make_printf_args(const Args &... args) { return {args...}; }
+    const Args &... args) {
+  return {args...};
+}
 
 /**
   \rst
@@ -727,14 +730,17 @@ inline format_arg_store<printf_context, Args...>
   \endrst
  */
 template <typename... Args>
-inline format_arg_store<wprintf_context, Args...>
+inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
-  make_wprintf_args(const Args &... args) { return {args...}; }
+    const Args &... args) {
+  return {args...};
+}
 
 template <typename S, typename Char = FMT_CHAR(S)>
-inline std::basic_string<Char>
+inline std::basic_string<Char> vsprintf(
-vsprintf(const S &format,
+    const S &format,
-         basic_format_args<typename basic_printf_context_t<
+    basic_format_args<
-           internal::basic_buffer<Char>>::type> args) {
+        typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
+        args) {
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   return to_string(buffer);
@@ -750,26 +756,28 @@ vsprintf(const S &format,
   \endrst
 */
 template <typename S, typename... Args>
-inline FMT_ENABLE_IF_T(
+inline FMT_ENABLE_IF_T(internal::is_string<S>::value,
-    internal::is_string<S>::value, std::basic_string<FMT_CHAR(S)>)
+                       std::basic_string<FMT_CHAR(S)>)
     sprintf(const S &format, const Args &... args) {
   internal::check_format_string<Args...>(format);
   typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
   typedef typename basic_printf_context_t<buffer>::type context;
   format_arg_store<context, Args...> as{args...};
-  return vsprintf(to_string_view(format),
+  return vsprintf(to_string_view(format), basic_format_args<context>(as));
-                  basic_format_args<context>(as));
 }
 
 template <typename S, typename Char = FMT_CHAR(S)>
-inline int vfprintf(std::FILE *f, const S &format,
+inline int vfprintf(
-                    basic_format_args<typename basic_printf_context_t<
+    std::FILE *f, const S &format,
-                      internal::basic_buffer<Char>>::type> args) {
+    basic_format_args<
+        typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
+        args) {
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   std::size_t size = buffer.size();
-  return std::fwrite(
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
-    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+             ? -1
+             : static_cast<int>(size);
 }
 
 /**
@@ -788,14 +796,15 @@ inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
   typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
   typedef typename basic_printf_context_t<buffer>::type context;
   format_arg_store<context, Args...> as{args...};
-  return vfprintf(f, to_string_view(format),
+  return vfprintf(f, to_string_view(format), basic_format_args<context>(as));
-                  basic_format_args<context>(as));
 }
 
 template <typename S, typename Char = FMT_CHAR(S)>
-inline int vprintf(const S &format,
+inline int vprintf(
-                   basic_format_args<typename basic_printf_context_t<
+    const S &format,
-                    internal::basic_buffer<Char>>::type> args) {
+    basic_format_args<
+        typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
+        args) {
   return vfprintf(stdout, to_string_view(format), args);
 }
 
@@ -815,15 +824,15 @@ inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
   typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
   typedef typename basic_printf_context_t<buffer>::type context;
   format_arg_store<context, Args...> as{args...};
-  return vprintf(to_string_view(format_str),
+  return vprintf(to_string_view(format_str), basic_format_args<context>(as));
-                 basic_format_args<context>(as));
 }
 
 template <typename S, typename Char = FMT_CHAR(S)>
-inline int vfprintf(std::basic_ostream<Char> &os,
+inline int vfprintf(
-                    const S &format,
+    std::basic_ostream<Char> &os, const S &format,
-                    basic_format_args<typename basic_printf_context_t<
+    basic_format_args<
-                      internal::basic_buffer<Char>>::type> args) {
+        typename basic_printf_context_t<internal::basic_buffer<Char>>::type>
+        args) {
   basic_memory_buffer<Char> buffer;
   printf(buffer, to_string_view(format), args);
   internal::write(os, buffer);
@@ -841,8 +850,8 @@ inline int vfprintf(std::basic_ostream<Char> &os,
  */
 template <typename S, typename... Args>
 inline FMT_ENABLE_IF_T(internal::is_string<S>::value, int)
-    fprintf(std::basic_ostream<FMT_CHAR(S)> &os,
+    fprintf(std::basic_ostream<FMT_CHAR(S)> &os, const S &format_str,
-            const S &format_str, const Args & ... args) {
+            const Args &... args) {
   internal::check_format_string<Args...>(format_str);
   typedef internal::basic_buffer<FMT_CHAR(S)> buffer;
   typedef typename basic_printf_context_t<buffer>::type context;

src/cpp/include/deps/spdlog/fmt/bundled/ranges.h

@@ -12,9 +12,10 @@
 #ifndef FMT_RANGES_H_
 #define FMT_RANGES_H_
 
-#include "format.h"
 #include <type_traits>
 
+#include "format.h"
+
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
 #define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
@@ -33,7 +34,8 @@ struct formatting_base {
 template <typename Char, typename Enable = void>
 struct formatting_range : formatting_base<Char> {
   static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
+                                      // range.
   Char prefix;
   Char delimiter;
   Char postfix;
@@ -77,8 +79,8 @@ void copy(char ch, OutputIterator out) {
 template <typename T>
 class is_like_std_string {
   template <typename U>
-  static auto check(U *p) ->
+  static auto check(U *p)
-    decltype(p->find('a'), p->length(), p->data(), int());
+      -> decltype(p->find('a'), p->length(), p->data(), int());
   template <typename>
   static void check(...);
 
@@ -98,7 +100,8 @@ struct is_range_ : std::false_type {};
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
 template <typename T>
-struct is_range_<T, typename std::conditional<
+struct is_range_<
+    T, typename std::conditional<
            false,
            conditional_helper<decltype(internal::declval<T>().begin()),
                               decltype(internal::declval<T>().end())>,
@@ -109,9 +112,10 @@ struct is_range_<T, typename std::conditional<
 template <typename T>
 class is_tuple_like_ {
   template <typename U>
-  static auto check(U *p) ->
+  static auto check(U *p)
-    decltype(std::tuple_size<U>::value,
+      -> decltype(std::tuple_size<U>::value,
-      internal::declval<typename std::tuple_element<0, U>::type>(), int());
+                  internal::declval<typename std::tuple_element<0, U>::type>(),
+                  int());
   template <typename>
   static void check(...);
 
@@ -133,9 +137,7 @@ template <typename T, T... N>
 struct integer_sequence {
   typedef T value_type;
 
-  static FMT_CONSTEXPR std::size_t size() {
+  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
-    return sizeof...(N);
-  }
 };
 
 template <std::size_t... N>
@@ -159,8 +161,10 @@ void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
 }
 
 template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-get_indexes(T const &) { return {}; }
+    T const &) {
+  return {};
+}
 
 template <class Tuple, class F>
 void for_each(Tuple &&tup, F &&f) {
@@ -169,23 +173,28 @@ void for_each(Tuple &&tup, F &&f) {
 }
 
 template <typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+FMT_CONSTEXPR const char *format_str_quoted(
+    bool add_space, const Arg &,
     typename std::enable_if<
-    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+        !is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
+        nullptr) {
   return add_space ? " {}" : "{}";
 }
 
 template <typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+FMT_CONSTEXPR const char *format_str_quoted(
+    bool add_space, const Arg &,
     typename std::enable_if<
-    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+        is_like_std_string<typename std::decay<Arg>::type>::value>::type * =
+        nullptr) {
   return add_space ? " \"{}\"" : "\"{}\"";
 }
 
 FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *) {
   return add_space ? " \"{}\"" : "\"{}\"";
 }
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
+FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space,
+                                               const wchar_t *) {
   return add_space ? L" \"{}\"" : L"\"{}\"";
 }
 
@@ -205,7 +214,8 @@ struct is_tuple_like {
 };
 
 template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, 
+struct formatter<
+    TupleT, Char,
     typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
  private:
   // C++11 generic lambda for format()
@@ -228,7 +238,8 @@ private:
 
     formatting_tuple<Char> &formatting;
     std::size_t &i;
-    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
+    typename std::add_lvalue_reference<decltype(
+        std::declval<FormatContext>().out())>::type out;
   };
 
  public:
@@ -264,7 +275,6 @@ struct is_range {
 template <typename RangeT, typename Char>
 struct formatter<RangeT, Char,
                  typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
-
   formatting_range<Char> formatting;
 
   template <typename ParseContext>
@@ -273,8 +283,8 @@ struct formatter<RangeT, Char,
   }
 
   template <typename FormatContext>
-  typename FormatContext::iterator format(
+  typename FormatContext::iterator format(const RangeT &values,
-      const RangeT &values, FormatContext &ctx) {
+                                          FormatContext &ctx) {
     auto out = ctx.out();
     internal::copy(formatting.prefix, out);
     std::size_t i = 0;
@@ -305,4 +315,3 @@ struct formatter<RangeT, Char,
 FMT_END_NAMESPACE
 
 #endif  // FMT_RANGES_H_
-

src/cpp/include/deps/spdlog/fmt/bundled/time.h

@@ -8,10 +8,11 @@
 #ifndef FMT_TIME_H_
 #define FMT_TIME_H_
 
-#include "format.h"
 #include <ctime>
 #include <locale>
 
+#include "format.h"
+
 FMT_BEGIN_NAMESPACE
 
 // Prevents expansion of a preceding token as a function-style macro.
@@ -58,8 +59,7 @@ inline std::tm localtime(std::time_t time) {
   };
   dispatcher lt(time);
   // Too big time values may be unsupported.
-  if (!lt.run())
+  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
-    FMT_THROW(format_error("time_t value out of range"));
   return lt.tm_;
 }
 
@@ -95,8 +95,7 @@ inline std::tm gmtime(std::time_t time) {
   };
   dispatcher gt(time);
   // Too big time values may be unsupported.
-  if (!gt.run())
+  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
-    FMT_THROW(format_error("time_t value out of range"));
   return gt.tm_;
 }
 
@@ -110,18 +109,16 @@ inline std::size_t strftime(wchar_t *str, std::size_t count,
                             const wchar_t *format, const std::tm *time) {
   return std::wcsftime(str, count, format, time);
 }
-}
+}  // namespace internal
 
 template <typename Char>
 struct formatter<std::tm, Char> {
   template <typename ParseContext>
   auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':')
+    if (it != ctx.end() && *it == ':') ++it;
-      ++it;
     auto end = it;
-    while (end != ctx.end() && *end != '}')
+    while (end != ctx.end() && *end != '}') ++end;
-      ++end;
     tm_format.reserve(internal::to_unsigned(end - it + 1));
     tm_format.append(it, end);
     tm_format.push_back('\0');

src/cpp/include/deps/spdlog/formatter.h

@@ -10,11 +10,11 @@
 
 namespace spdlog {
 
-class formatter
+class formatter {
-{
  public:
   virtual ~formatter() = default;
-    virtual void format(const details::log_msg &msg, fmt::memory_buffer &dest) = 0;
+  virtual void format(const details::log_msg &msg,
+                      fmt::memory_buffer &dest) = 0;
   virtual std::unique_ptr<formatter> clone() const = 0;
 };
 }  // namespace spdlog

src/cpp/include/deps/spdlog/logger.h

@@ -18,18 +18,17 @@
 // formatted data,
 // and support customize format per each sink.
 
-#include "spdlog/common.h"
-#include "spdlog/formatter.h"
-#include "spdlog/sinks/sink.h"
-
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "spdlog/common.h"
+#include "spdlog/formatter.h"
+#include "spdlog/sinks/sink.h"
+
 namespace spdlog {
 
-class logger
+class logger {
-{
  public:
   logger(std::string name, sink_ptr single_sink);
   logger(std::string name, sinks_init_list sinks);
@@ -46,7 +45,8 @@ public:
   void log(level::level_enum lvl, const char *fmt, const Args &... args);
 
   template <typename... Args>
-    void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args);
+  void log(source_loc loc, level::level_enum lvl, const char *fmt,
+           const Args &... args);
 
   void log(level::level_enum lvl, const char *msg);
 
@@ -78,7 +78,8 @@ public:
   void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args);
 
   template <typename... Args>
-    void log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args);
+  void log(source_loc source, level::level_enum lvl, const wchar_t *fmt,
+           const Args &... args);
 
   template <typename... Args>
   void trace(const wchar_t *fmt, const Args &... args);
@@ -101,19 +102,27 @@ public:
 #endif  // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
   // T can be statically converted to string_view
-    template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
+  template <class T, typename std::enable_if<
+                         std::is_convertible<T, spdlog::string_view_t>::value,
+                         T>::type * = nullptr>
   void log(level::level_enum lvl, const T &);
 
   // T can be statically converted to string_view
-    template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
+  template <class T, typename std::enable_if<
+                         std::is_convertible<T, spdlog::string_view_t>::value,
+                         T>::type * = nullptr>
   void log(source_loc loc, level::level_enum lvl, const T &);
 
   // T cannot be statically converted to string_view
-    template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
+  template <class T, typename std::enable_if<
+                         !std::is_convertible<T, spdlog::string_view_t>::value,
+                         T>::type * = nullptr>
   void log(level::level_enum lvl, const T &);
 
   // T cannot be statically converted to string_view
-    template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
+  template <class T, typename std::enable_if<
+                         !std::is_convertible<T, spdlog::string_view_t>::value,
+                         T>::type * = nullptr>
   void log(source_loc loc, level::level_enum lvl, const T &);
 
   template <typename T>
@@ -144,7 +153,8 @@ public:
   // set formatting for the sinks in this logger.
   // each sink will get a seperate instance of the formatter object.
   void set_formatter(std::unique_ptr<formatter> formatter);
-    void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
+  void set_pattern(std::string pattern,
+                   pattern_time_type time_type = pattern_time_type::local);
 
   // flush functions
   void flush();
@@ -172,14 +182,16 @@ protected:
   // print the error to stderr with the max rate of 1 message/minute.
   void default_err_handler_(const std::string &msg);
 
-    // increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
+  // increment the message count (only if
+  // defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
   void incr_msg_counter_(details::log_msg &msg);
 
   const std::string name_;
   std::vector<sink_ptr> sinks_;
   spdlog::level_t level_{spdlog::logger::default_level()};
   spdlog::level_t flush_level_{level::off};
-    log_err_handler err_handler_{[this](const std::string &msg) { this->default_err_handler_(msg); }};
+  log_err_handler err_handler_{
+      [this](const std::string &msg) { this->default_err_handler_(msg); }};
   std::atomic<time_t> last_err_time_{0};
   std::atomic<size_t> msg_counter_{1};
 };

src/cpp/include/deps/spdlog/sinks/android_sink.h

@@ -9,17 +9,18 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/details/os.h"
-#include "spdlog/sinks/base_sink.h"
-
 #include <android/log.h>
+
 #include <chrono>
 #include <mutex>
 #include <string>
 #include <thread>
 
+#include "spdlog/details/fmt_helper.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/details/os.h"
+#include "spdlog/sinks/base_sink.h"
+
 #if !defined(SPDLOG_ANDROID_RETRIES)
 #define SPDLOG_ANDROID_RETRIES 2
 #endif
@@ -31,26 +32,18 @@ namespace sinks {
  * Android sink (logging using __android_log_write)
  */
 template <typename Mutex>
-class android_sink final : public base_sink<Mutex>
+class android_sink final : public base_sink<Mutex> {
-{
  public:
   explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
-        : tag_(std::move(tag))
+      : tag_(std::move(tag)), use_raw_msg_(use_raw_msg) {}
-        , use_raw_msg_(use_raw_msg)
-    {
-    }
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
     const android_LogPriority priority = convert_to_android_(msg.level);
     fmt::memory_buffer formatted;
-        if (use_raw_msg_)
+    if (use_raw_msg_) {
-        {
       details::fmt_helper::append_string_view(msg.payload, formatted);
-        }
+    } else {
-        else
-        {
       sink::formatter_->format(msg, formatted);
     }
     formatted.push_back('\0');
@@ -59,15 +52,13 @@ protected:
     // See system/core/liblog/logger_write.c for explanation of return value
     int ret = __android_log_write(priority, tag_.c_str(), msg_output);
     int retry_count = 0;
-        while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
+    while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
-        {
       details::os::sleep_for_millis(5);
       ret = __android_log_write(priority, tag_.c_str(), msg_output);
       retry_count++;
     }
 
-        if (ret < 0)
+    if (ret < 0) {
-        {
       throw spdlog_ex("__android_log_write() failed", ret);
     }
   }
@@ -75,10 +66,9 @@ protected:
   void flush_() override {}
 
  private:
-    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
+  static android_LogPriority convert_to_android_(
-    {
+      spdlog::level::level_enum level) {
-        switch (level)
+    switch (level) {
-        {
       case spdlog::level::trace:
         return ANDROID_LOG_VERBOSE;
       case spdlog::level::debug:
@@ -107,14 +97,14 @@ using android_sink_st = android_sink<details::null_mutex>;
 // Create and register android syslog logger
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_mt(
-{
+    const std::string &logger_name, const std::string &tag = "spdlog") {
   return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_st(
-{
+    const std::string &logger_name, const std::string &tag = "spdlog") {
   return Factory::template create<sinks::android_sink_st>(logger_name, tag);
 }
 

src/cpp/include/deps/spdlog/sinks/ansicolor_sink.h

@@ -9,16 +9,16 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/console_globals.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/details/os.h"
-#include "spdlog/sinks/sink.h"
-
 #include <memory>
 #include <mutex>
 #include <string>
 #include <unordered_map>
 
+#include "spdlog/details/console_globals.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/details/os.h"
+#include "spdlog/sinks/sink.h"
+
 namespace spdlog {
 namespace sinks {
 
@@ -29,16 +29,16 @@ namespace sinks {
  * If no color terminal detected, omit the escape codes.
  */
 template <typename TargetStream, class ConsoleMutex>
-class ansicolor_sink final : public sink
+class ansicolor_sink final : public sink {
-{
  public:
   using mutex_t = typename ConsoleMutex::mutex_t;
   ansicolor_sink()
-        : target_file_(TargetStream::stream())
+      : target_file_(TargetStream::stream()),
-        , mutex_(ConsoleMutex::mutex())
+        mutex_(ConsoleMutex::mutex())
 
   {
-        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
+    should_do_colors_ = details::os::in_terminal(target_file_) &&
+                        details::os::is_color_terminal();
     colors_[level::trace] = white;
     colors_[level::debug] = cyan;
     colors_[level::info] = green;
@@ -53,8 +53,7 @@ public:
   ansicolor_sink(const ansicolor_sink &other) = delete;
   ansicolor_sink &operator=(const ansicolor_sink &other) = delete;
 
-    void set_color(level::level_enum color_level, const std::string &color)
+  void set_color(level::level_enum color_level, const std::string &color) {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     colors_[color_level] = color;
   }
@@ -89,16 +88,14 @@ public:
   const std::string on_cyan = "\033[46m";
   const std::string on_white = "\033[47m";
 
-    void log(const details::log_msg &msg) override
+  void log(const details::log_msg &msg) override {
-    {
     // Wrap the originally formatted message in color codes.
     // If color is not supported in the terminal, log as is instead.
     std::lock_guard<mutex_t> lock(mutex_);
 
     fmt::memory_buffer formatted;
     formatter_->format(msg, formatted);
-        if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
+    if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
-        {
       // before color range
       print_range_(formatted, 0, msg.color_range_start);
       // in color range
@@ -107,39 +104,36 @@ public:
       print_ccode_(reset);
       // after color range
       print_range_(formatted, msg.color_range_end, formatted.size());
-        }
+    } else  // no color
-        else // no color
     {
       print_range_(formatted, 0, formatted.size());
     }
     fflush(target_file_);
   }
 
-    void flush() override
+  void flush() override {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     fflush(target_file_);
   }
 
-    void set_pattern(const std::string &pattern) final
+  void set_pattern(const std::string &pattern) final {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
-        formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+    formatter_ =
+        std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
   }
 
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
+  void set_formatter(
-    {
+      std::unique_ptr<spdlog::formatter> sink_formatter) override {
     std::lock_guard<mutex_t> lock(mutex_);
     formatter_ = std::move(sink_formatter);
   }
 
  private:
-    void print_ccode_(const std::string &color_code)
+  void print_ccode_(const std::string &color_code) {
-    {
     fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
   }
-    void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end)
+  void print_range_(const fmt::memory_buffer &formatted, size_t start,
-    {
+                    size_t end) {
     fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
   }
 
@@ -147,14 +141,19 @@ private:
   mutex_t &mutex_;
 
   bool should_do_colors_;
-    std::unordered_map<level::level_enum, std::string, level::level_hasher> colors_;
+  std::unordered_map<level::level_enum, std::string, level::level_hasher>
+      colors_;
 };
 
-using ansicolor_stdout_sink_mt = ansicolor_sink<details::console_stdout, details::console_mutex>;
+using ansicolor_stdout_sink_mt =
-using ansicolor_stdout_sink_st = ansicolor_sink<details::console_stdout, details::console_nullmutex>;
+    ansicolor_sink<details::console_stdout, details::console_mutex>;
+using ansicolor_stdout_sink_st =
+    ansicolor_sink<details::console_stdout, details::console_nullmutex>;
 
-using ansicolor_stderr_sink_mt = ansicolor_sink<details::console_stderr, details::console_mutex>;
+using ansicolor_stderr_sink_mt =
-using ansicolor_stderr_sink_st = ansicolor_sink<details::console_stderr, details::console_nullmutex>;
+    ansicolor_sink<details::console_stderr, details::console_mutex>;
+using ansicolor_stderr_sink_st =
+    ansicolor_sink<details::console_stderr, details::console_nullmutex>;
 
 }  // namespace sinks
 

src/cpp/include/deps/spdlog/sinks/base_sink.h

@@ -19,33 +19,28 @@
 namespace spdlog {
 namespace sinks {
 template <typename Mutex>
-class base_sink : public sink
+class base_sink : public sink {
-{
  public:
   base_sink() = default;
   base_sink(const base_sink &) = delete;
   base_sink &operator=(const base_sink &) = delete;
 
-    void log(const details::log_msg &msg) final
+  void log(const details::log_msg &msg) final {
-    {
     std::lock_guard<Mutex> lock(mutex_);
     sink_it_(msg);
   }
 
-    void flush() final
+  void flush() final {
-    {
     std::lock_guard<Mutex> lock(mutex_);
     flush_();
   }
 
-    void set_pattern(const std::string &pattern) final
+  void set_pattern(const std::string &pattern) final {
-    {
     std::lock_guard<Mutex> lock(mutex_);
     set_pattern_(pattern);
   }
 
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final
+  void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final {
-    {
     std::lock_guard<Mutex> lock(mutex_);
     set_formatter_(std::move(sink_formatter));
   }
@@ -54,13 +49,12 @@ protected:
   virtual void sink_it_(const details::log_msg &msg) = 0;
   virtual void flush_() = 0;
 
-    virtual void set_pattern_(const std::string &pattern)
+  virtual void set_pattern_(const std::string &pattern) {
-    {
     set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
   }
 
-    virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
+  virtual void set_formatter_(
-    {
+      std::unique_ptr<spdlog::formatter> sink_formatter) {
     formatter_ = std::move(sink_formatter);
   }
   Mutex mutex_;

src/cpp/include/deps/spdlog/sinks/basic_file_sink.h

@@ -9,39 +9,33 @@
 #include "spdlog/spdlog.h"
 #endif
 
+#include <mutex>
+#include <string>
+
 #include "spdlog/details/file_helper.h"
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/base_sink.h"
 
-#include <mutex>
-#include <string>
-
 namespace spdlog {
 namespace sinks {
 /*
  * Trivial file sink with single file as target
  */
 template <typename Mutex>
-class basic_file_sink final : public base_sink<Mutex>
+class basic_file_sink final : public base_sink<Mutex> {
-{
  public:
-    explicit basic_file_sink(const filename_t &filename, bool truncate = false)
+  explicit basic_file_sink(const filename_t &filename, bool truncate = false) {
-    {
     file_helper_.open(filename, truncate);
   }
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
     fmt::memory_buffer formatted;
     sink::formatter_->format(msg, formatted);
     file_helper_.write(formatted);
   }
 
-    void flush_() override
+  void flush_() override { file_helper_.flush(); }
-    {
-        file_helper_.flush();
-    }
 
  private:
   details::file_helper file_helper_;
@@ -56,15 +50,19 @@ using basic_file_sink_st = basic_file_sink<details::null_mutex>;
 // factory functions
 //
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false)
+inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
-{
+                                               const filename_t &filename,
-    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate);
+                                               bool truncate = false) {
+  return Factory::template create<sinks::basic_file_sink_mt>(
+      logger_name, filename, truncate);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false)
+inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
-{
+                                               const filename_t &filename,
-    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate);
+                                               bool truncate = false) {
+  return Factory::template create<sinks::basic_file_sink_st>(
+      logger_name, filename, truncate);
 }
 
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/daily_file_sink.h

@@ -9,33 +9,35 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/file_helper.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/sinks/base_sink.h"
-
 #include <chrono>
 #include <cstdio>
 #include <ctime>
 #include <mutex>
 #include <string>
 
+#include "spdlog/details/file_helper.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/fmt/fmt.h"
+#include "spdlog/sinks/base_sink.h"
+
 namespace spdlog {
 namespace sinks {
 
 /*
  * Generator of daily log file names in format basename.YYYY-MM-DD.ext
  */
-struct daily_filename_calculator
+struct daily_filename_calculator {
-{
   // Create filename for the form basename.YYYY-MM-DD
-    static filename_t calc_filename(const filename_t &filename, const tm &now_tm)
+  static filename_t calc_filename(const filename_t &filename,
-    {
+                                  const tm &now_tm) {
     filename_t basename, ext;
-        std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+    std::tie(basename, ext) =
-        std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w;
+        details::file_helper::split_by_extension(filename);
-        fmt::format_to(
+    std::conditional<std::is_same<filename_t::value_type, char>::value,
-            w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
+                     fmt::memory_buffer, fmt::wmemory_buffer>::type w;
+    fmt::format_to(w, SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename,
+                   now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+                   ext);
     return fmt::to_string(w);
   }
 };
@@ -44,32 +46,31 @@ struct daily_filename_calculator
  * Rotating file sink based on date. rotates at midnight
  */
 template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
-class daily_file_sink final : public base_sink<Mutex>
+class daily_file_sink final : public base_sink<Mutex> {
-{
  public:
   // create daily file sink which rotates on given time
-    daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false)
+  daily_file_sink(filename_t base_filename, int rotation_hour,
-        : base_filename_(std::move(base_filename))
+                  int rotation_minute, bool truncate = false)
-        , rotation_h_(rotation_hour)
+      : base_filename_(std::move(base_filename)),
-        , rotation_m_(rotation_minute)
+        rotation_h_(rotation_hour),
-        , truncate_(truncate)
+        rotation_m_(rotation_minute),
-    {
+        truncate_(truncate) {
-        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
+    if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
-        {
+        rotation_minute > 59) {
       throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
     }
     auto now = log_clock::now();
-        file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)), truncate_);
+    file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(now)),
+                      truncate_);
     rotation_tp_ = next_rotation_tp_();
   }
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
+    if (msg.time >= rotation_tp_) {
-
+      file_helper_.open(
-        if (msg.time >= rotation_tp_)
+          FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)),
-        {
+          truncate_);
-            file_helper_.open(FileNameCalc::calc_filename(base_filename_, now_tm(msg.time)), truncate_);
       rotation_tp_ = next_rotation_tp_();
     }
     fmt::memory_buffer formatted;
@@ -77,28 +78,22 @@ protected:
     file_helper_.write(formatted);
   }
 
-    void flush_() override
+  void flush_() override { file_helper_.flush(); }
-    {
-        file_helper_.flush();
-    }
 
  private:
-    tm now_tm(log_clock::time_point tp)
+  tm now_tm(log_clock::time_point tp) {
-    {
     time_t tnow = log_clock::to_time_t(tp);
     return spdlog::details::os::localtime(tnow);
   }
 
-    log_clock::time_point next_rotation_tp_()
+  log_clock::time_point next_rotation_tp_() {
-    {
     auto now = log_clock::now();
     tm date = now_tm(now);
     date.tm_hour = rotation_h_;
     date.tm_min = rotation_m_;
     date.tm_sec = 0;
     auto rotation_time = log_clock::from_time_t(std::mktime(&date));
-        if (rotation_time > now)
+    if (rotation_time > now) {
-        {
       return rotation_time;
     }
     return {rotation_time + std::chrono::hours(24)};
@@ -121,16 +116,20 @@ using daily_file_sink_st = daily_file_sink<details::null_mutex>;
 // factory functions
 //
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> daily_logger_mt(
+inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false)
+                                               const filename_t &filename,
-{
+                                               int hour = 0, int minute = 0,
-    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate);
+                                               bool truncate = false) {
+  return Factory::template create<sinks::daily_file_sink_mt>(
+      logger_name, filename, hour, minute, truncate);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> daily_logger_st(
+inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
-    const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false)
+                                               const filename_t &filename,
-{
+                                               int hour = 0, int minute = 0,
-    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate);
+                                               bool truncate = false) {
+  return Factory::template create<sinks::daily_file_sink_st>(
+      logger_name, filename, hour, minute, truncate);
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/dist_sink.h

@@ -9,15 +9,15 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "base_sink.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/null_mutex.h"
-
 #include <algorithm>
 #include <memory>
 #include <mutex>
 #include <vector>
 
+#include "base_sink.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/null_mutex.h"
+
 // Distribution sink (mux). Stores a vector of sinks which get called when log
 // is called
 
@@ -25,62 +25,50 @@ namespace spdlog {
 namespace sinks {
 
 template <typename Mutex>
-class dist_sink : public base_sink<Mutex>
+class dist_sink : public base_sink<Mutex> {
-{
  public:
   dist_sink() = default;
   dist_sink(const dist_sink &) = delete;
   dist_sink &operator=(const dist_sink &) = delete;
 
-    void add_sink(std::shared_ptr<sink> sink)
+  void add_sink(std::shared_ptr<sink> sink) {
-    {
     std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
     sinks_.push_back(sink);
   }
 
-    void remove_sink(std::shared_ptr<sink> sink)
+  void remove_sink(std::shared_ptr<sink> sink) {
-    {
     std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
     sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
   }
 
-    void set_sinks(std::vector<std::shared_ptr<sink>> sinks)
+  void set_sinks(std::vector<std::shared_ptr<sink>> sinks) {
-    {
     std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
     sinks_ = std::move(sinks);
   }
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
+    for (auto &sink : sinks_) {
-
+      if (sink->should_log(msg.level)) {
-        for (auto &sink : sinks_)
-        {
-            if (sink->should_log(msg.level))
-            {
         sink->log(msg);
       }
     }
   }
 
-    void flush_() override
+  void flush_() override {
-    {
+    for (auto &sink : sinks_) {
-        for (auto &sink : sinks_)
-        {
       sink->flush();
     }
   }
 
-    void set_pattern_(const std::string &pattern) override
+  void set_pattern_(const std::string &pattern) override {
-    {
     set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
   }
 
-    void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
+  void set_formatter_(
-    {
+      std::unique_ptr<spdlog::formatter> sink_formatter) override {
     base_sink<Mutex>::formatter_ = std::move(sink_formatter);
-        for (auto &sink : sinks_)
+    for (auto &sink : sinks_) {
-        {
       sink->set_formatter(base_sink<Mutex>::formatter_->clone());
     }
   }

src/cpp/include/deps/spdlog/sinks/msvc_sink.h

@@ -11,29 +11,26 @@
 
 #if defined(_WIN32)
 
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-
 #include <winbase.h>
 
 #include <mutex>
 #include <string>
 
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/base_sink.h"
+
 namespace spdlog {
 namespace sinks {
 /*
  * MSVC sink (logging using OutputDebugStringA)
  */
 template <typename Mutex>
-class msvc_sink : public base_sink<Mutex>
+class msvc_sink : public base_sink<Mutex> {
-{
  public:
   explicit msvc_sink() {}
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
-
     fmt::memory_buffer formatted;
     sink::formatter_->format(msg, formatted);
     OutputDebugStringA(fmt::to_string(formatted).c_str());

src/cpp/include/deps/spdlog/sinks/null_sink.h

@@ -9,17 +9,16 @@
 #include "spdlog/spdlog.h"
 #endif
 
+#include <mutex>
+
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/base_sink.h"
 
-#include <mutex>
-
 namespace spdlog {
 namespace sinks {
 
 template <typename Mutex>
-class null_sink : public base_sink<Mutex>
+class null_sink : public base_sink<Mutex> {
-{
  protected:
   void sink_it_(const details::log_msg &) override {}
   void flush_() override {}
@@ -31,16 +30,14 @@ using null_sink_st = null_sink<details::null_mutex>;
 }  // namespace sinks
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name)
+inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
-{
   auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
   null_logger->set_level(level::off);
   return null_logger;
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name)
+inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
-{
   auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
   null_logger->set_level(level::off);
   return null_logger;

src/cpp/include/deps/spdlog/sinks/ostream_sink.h

@@ -9,42 +9,34 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-
 #include <mutex>
 #include <ostream>
 
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/base_sink.h"
+
 namespace spdlog {
 namespace sinks {
 template <typename Mutex>
-class ostream_sink final : public base_sink<Mutex>
+class ostream_sink final : public base_sink<Mutex> {
-{
  public:
   explicit ostream_sink(std::ostream &os, bool force_flush = false)
-        : ostream_(os)
+      : ostream_(os), force_flush_(force_flush) {}
-        , force_flush_(force_flush)
-    {
-    }
   ostream_sink(const ostream_sink &) = delete;
   ostream_sink &operator=(const ostream_sink &) = delete;
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
     fmt::memory_buffer formatted;
     sink::formatter_->format(msg, formatted);
-        ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
+    ostream_.write(formatted.data(),
-        if (force_flush_)
+                   static_cast<std::streamsize>(formatted.size()));
-        {
+    if (force_flush_) {
       ostream_.flush();
     }
   }
 
-    void flush_() override
+  void flush_() override { ostream_.flush(); }
-    {
-        ostream_.flush();
-    }
 
   std::ostream &ostream_;
   bool force_flush_;

src/cpp/include/deps/spdlog/sinks/rotating_file_sink.h

@@ -9,11 +9,6 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/file_helper.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/sinks/base_sink.h"
-
 #include <cerrno>
 #include <chrono>
 #include <ctime>
@@ -21,6 +16,11 @@
 #include <string>
 #include <tuple>
 
+#include "spdlog/details/file_helper.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/fmt/fmt.h"
+#include "spdlog/sinks/base_sink.h"
+
 namespace spdlog {
 namespace sinks {
 
@@ -28,54 +28,47 @@ namespace sinks {
 // Rotating file sink based on size
 //
 template <typename Mutex>
-class rotating_file_sink final : public base_sink<Mutex>
+class rotating_file_sink final : public base_sink<Mutex> {
-{
  public:
-    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files)
+  rotating_file_sink(filename_t base_filename, std::size_t max_size,
-        : base_filename_(std::move(base_filename))
+                     std::size_t max_files)
-        , max_size_(max_size)
+      : base_filename_(std::move(base_filename)),
-        , max_files_(max_files)
+        max_size_(max_size),
-    {
+        max_files_(max_files) {
     file_helper_.open(calc_filename(base_filename_, 0));
     current_size_ = file_helper_.size();  // expensive. called only once
   }
 
   // calc filename according to index and file extension if exists.
   // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
-    static filename_t calc_filename(const filename_t &filename, std::size_t index)
+  static filename_t calc_filename(const filename_t &filename,
-    {
+                                  std::size_t index) {
-        typename std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::memory_buffer, fmt::wmemory_buffer>::type w;
+    typename std::conditional<std::is_same<filename_t::value_type, char>::value,
-        if (index != 0u)
+                              fmt::memory_buffer, fmt::wmemory_buffer>::type w;
-        {
+    if (index != 0u) {
       filename_t basename, ext;
-            std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+      std::tie(basename, ext) =
+          details::file_helper::split_by_extension(filename);
       fmt::format_to(w, SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
-        }
+    } else {
-        else
-        {
       fmt::format_to(w, SPDLOG_FILENAME_T("{}"), filename);
     }
     return fmt::to_string(w);
   }
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
     fmt::memory_buffer formatted;
     sink::formatter_->format(msg, formatted);
     current_size_ += formatted.size();
-        if (current_size_ > max_size_)
+    if (current_size_ > max_size_) {
-        {
       rotate_();
       current_size_ = formatted.size();
     }
     file_helper_.write(formatted);
   }
 
-    void flush_() override
+  void flush_() override { file_helper_.flush(); }
-    {
-        file_helper_.flush();
-    }
 
  private:
   // Rotate files:
@@ -83,31 +76,30 @@ private:
   // log.1.txt -> log.2.txt
   // log.2.txt -> log.3.txt
   // log.3.txt -> delete
-    void rotate_()
+  void rotate_() {
-    {
     using details::os::filename_to_str;
     file_helper_.close();
-        for (auto i = max_files_; i > 0; --i)
+    for (auto i = max_files_; i > 0; --i) {
-        {
       filename_t src = calc_filename(base_filename_, i - 1);
-            if (!details::file_helper::file_exists(src))
+      if (!details::file_helper::file_exists(src)) {
-            {
         continue;
       }
       filename_t target = calc_filename(base_filename_, i);
 
-            if (!rename_file(src, target))
+      if (!rename_file(src, target)) {
-            {
         // if failed try again after a small delay.
         // this is a workaround to a windows issue, where very high rotation
-                // rates can cause the rename to fail with permission denied (because of antivirus?).
+        // rates can cause the rename to fail with permission denied (because of
+        // antivirus?).
         details::os::sleep_for_millis(100);
-                if (!rename_file(src, target))
+        if (!rename_file(src, target)) {
-                {
+          file_helper_.reopen(true);  // truncate the log file anyway to prevent
-                    file_helper_.reopen(true); // truncate the log file anyway to prevent it to grow beyond its limit!
+                                      // it to grow beyond its limit!
           current_size_ = 0;
-                    throw spdlog_ex(
+          throw spdlog_ex("rotating_file_sink: failed renaming " +
-                        "rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
+                              filename_to_str(src) + " to " +
+                              filename_to_str(target),
+                          errno);
         }
       }
     }
@@ -116,8 +108,8 @@ private:
 
   // delete the target if exists, and rename the src file  to target
   // return true on success, false otherwise.
-    bool rename_file(const filename_t &src_filename, const filename_t &target_filename)
+  bool rename_file(const filename_t &src_filename,
-    {
+                   const filename_t &target_filename) {
     // try to delete the target file in case it already exists.
     (void)details::os::remove(target_filename);
     return details::os::rename(src_filename, target_filename) == 0;
@@ -141,15 +133,17 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
 
 template <typename Factory = default_factory>
 inline std::shared_ptr<logger> rotating_logger_mt(
-    const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
+    const std::string &logger_name, const filename_t &filename,
-{
+    size_t max_file_size, size_t max_files) {
-    return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files);
+  return Factory::template create<sinks::rotating_file_sink_mt>(
+      logger_name, filename, max_file_size, max_files);
 }
 
 template <typename Factory = default_factory>
 inline std::shared_ptr<logger> rotating_logger_st(
-    const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
+    const std::string &logger_name, const filename_t &filename,
-{
+    size_t max_file_size, size_t max_files) {
-    return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files);
+  return Factory::template create<sinks::rotating_file_sink_st>(
+      logger_name, filename, max_file_size, max_files);
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/sink.h

@@ -11,40 +11,29 @@
 
 namespace spdlog {
 namespace sinks {
-class sink
+class sink {
-{
  public:
-    sink()
+  sink() : level_(level::trace), formatter_(new pattern_formatter()) {}
-        : level_(level::trace)
-        , formatter_(new pattern_formatter())
-    {
-    }
 
   explicit sink(std::unique_ptr<spdlog::pattern_formatter> formatter)
-        : level_(level::trace)
+      : level_(level::trace), formatter_(std::move(formatter)) {}
-        , formatter_(std::move(formatter))
-    {
-    }
 
   virtual ~sink() = default;
   virtual void log(const details::log_msg &msg) = 0;
   virtual void flush() = 0;
   virtual void set_pattern(const std::string &pattern) = 0;
-    virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
+  virtual void set_formatter(
+      std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
 
-    bool should_log(level::level_enum msg_level) const
+  bool should_log(level::level_enum msg_level) const {
-    {
     return msg_level >= level_.load(std::memory_order_relaxed);
   }
 
-    void set_level(level::level_enum log_level)
+  void set_level(level::level_enum log_level) { level_.store(log_level); }
-    {
-        level_.store(log_level);
-    }
 
-    level::level_enum level() const
+  level::level_enum level() const {
-    {
+    return static_cast<spdlog::level::level_enum>(
-        return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
+        level_.load(std::memory_order_relaxed));
   }
 
  protected:

src/cpp/include/deps/spdlog/sinks/stdout_color_sinks.h

@@ -31,26 +31,22 @@ using stderr_color_sink_st = ansicolor_stderr_sink_st;
 }  // namespace sinks
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name)
+inline std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name) {
-{
   return Factory::template create<sinks::stdout_color_sink_mt>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stdout_color_st(const std::string &logger_name)
+inline std::shared_ptr<logger> stdout_color_st(const std::string &logger_name) {
-{
   return Factory::template create<sinks::stdout_color_sink_st>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name)
+inline std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name) {
-{
   return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stderr_color_st(const std::string &logger_name)
+inline std::shared_ptr<logger> stderr_color_st(const std::string &logger_name) {
-{
   return Factory::template create<sinks::stderr_color_sink_mt>(logger_name);
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/stdout_sinks.h

@@ -9,34 +9,29 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/details/console_globals.h"
-#include "spdlog/details/null_mutex.h"
-
 #include <cstdio>
 #include <memory>
 #include <mutex>
 
+#include "spdlog/details/console_globals.h"
+#include "spdlog/details/null_mutex.h"
+
 namespace spdlog {
 
 namespace sinks {
 
 template <typename TargetStream, typename ConsoleMutex>
-class stdout_sink final : public sink
+class stdout_sink final : public sink {
-{
  public:
   using mutex_t = typename ConsoleMutex::mutex_t;
   stdout_sink()
-        : mutex_(ConsoleMutex::mutex())
+      : mutex_(ConsoleMutex::mutex()), file_(TargetStream::stream()) {}
-        , file_(TargetStream::stream())
-    {
-    }
   ~stdout_sink() override = default;
 
   stdout_sink(const stdout_sink &other) = delete;
   stdout_sink &operator=(const stdout_sink &other) = delete;
 
-    void log(const details::log_msg &msg) override
+  void log(const details::log_msg &msg) override {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     fmt::memory_buffer formatted;
     formatter_->format(msg, formatted);
@@ -44,20 +39,19 @@ public:
     fflush(TargetStream::stream());
   }
 
-    void flush() override
+  void flush() override {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     fflush(file_);
   }
 
-    void set_pattern(const std::string &pattern) override
+  void set_pattern(const std::string &pattern) override {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
-        formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+    formatter_ =
+        std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
   }
 
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
+  void set_formatter(
-    {
+      std::unique_ptr<spdlog::formatter> sink_formatter) override {
     std::lock_guard<mutex_t> lock(mutex_);
     formatter_ = std::move(sink_formatter);
   }
@@ -67,36 +61,40 @@ private:
   FILE *file_;
 };
 
-using stdout_sink_mt = stdout_sink<details::console_stdout, details::console_mutex>;
+using stdout_sink_mt =
-using stdout_sink_st = stdout_sink<details::console_stdout, details::console_nullmutex>;
+    stdout_sink<details::console_stdout, details::console_mutex>;
+using stdout_sink_st =
+    stdout_sink<details::console_stdout, details::console_nullmutex>;
 
-using stderr_sink_mt = stdout_sink<details::console_stderr, details::console_mutex>;
+using stderr_sink_mt =
-using stderr_sink_st = stdout_sink<details::console_stderr, details::console_nullmutex>;
+    stdout_sink<details::console_stderr, details::console_mutex>;
+using stderr_sink_st =
+    stdout_sink<details::console_stderr, details::console_nullmutex>;
 
 }  // namespace sinks
 
 // factory methods
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
+inline std::shared_ptr<logger> stdout_logger_mt(
-{
+    const std::string &logger_name) {
   return Factory::template create<sinks::stdout_sink_mt>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
+inline std::shared_ptr<logger> stdout_logger_st(
-{
+    const std::string &logger_name) {
   return Factory::template create<sinks::stdout_sink_st>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
+inline std::shared_ptr<logger> stderr_logger_mt(
-{
+    const std::string &logger_name) {
   return Factory::template create<sinks::stderr_sink_mt>(logger_name);
 }
 
 template <typename Factory = default_factory>
-inline std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
+inline std::shared_ptr<logger> stderr_logger_st(
-{
+    const std::string &logger_name) {
   return Factory::template create<sinks::stderr_sink_st>(logger_name);
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/syslog_sink.h

@@ -9,11 +9,12 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/sinks/base_sink.h"
+#include <syslog.h>
 
 #include <array>
 #include <string>
-#include <syslog.h>
+
+#include "spdlog/sinks/base_sink.h"
 
 namespace spdlog {
 namespace sinks {
@@ -23,13 +24,12 @@ namespace sinks {
  * Locking is not needed, as `syslog()` itself is thread-safe.
  */
 template <typename Mutex>
-class syslog_sink : public base_sink<Mutex>
+class syslog_sink : public base_sink<Mutex> {
-{
  public:
   //
-    explicit syslog_sink(std::string ident = "", int syslog_option = 0, int syslog_facility = LOG_USER)
+  explicit syslog_sink(std::string ident = "", int syslog_option = 0,
-        : ident_(std::move(ident))
+                       int syslog_facility = LOG_USER)
-    {
+      : ident_(std::move(ident)) {
     priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG;
     priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG;
     priorities_[static_cast<size_t>(level::info)] = LOG_INFO;
@@ -39,21 +39,19 @@ public:
     priorities_[static_cast<size_t>(level::off)] = LOG_INFO;
 
     // set ident to be program name if empty
-        ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);
+    ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option,
+              syslog_facility);
   }
 
-    ~syslog_sink() override
+  ~syslog_sink() override { ::closelog(); }
-    {
-        ::closelog();
-    }
 
   syslog_sink(const syslog_sink &) = delete;
   syslog_sink &operator=(const syslog_sink &) = delete;
 
  protected:
-    void sink_it_(const details::log_msg &msg) override
+  void sink_it_(const details::log_msg &msg) override {
-    {
+    ::syslog(syslog_prio_from_level(msg), "%s",
-        ::syslog(syslog_prio_from_level(msg), "%s", fmt::to_string(msg.payload).c_str());
+             fmt::to_string(msg.payload).c_str());
   }
 
   void flush_() override {}
@@ -67,8 +65,7 @@ private:
   //
   // Simply maps spdlog's log level to syslog priority level.
   //
-    int syslog_prio_from_level(const details::log_msg &msg) const
+  int syslog_prio_from_level(const details::log_msg &msg) const {
-    {
     return priorities_[static_cast<size_t>(msg.level)];
   }
 };
@@ -80,15 +77,17 @@ using syslog_sink_st = syslog_sink<details::null_mutex>;
 // Create and register a syslog logger
 template <typename Factory = default_factory>
 inline std::shared_ptr<logger> syslog_logger_mt(
-    const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3))
+    const std::string &logger_name, const std::string &syslog_ident = "",
-{
+    int syslog_option = 0, int syslog_facility = (1 << 3)) {
-    return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, syslog_facility);
+  return Factory::template create<sinks::syslog_sink_mt>(
+      logger_name, syslog_ident, syslog_option, syslog_facility);
 }
 
 template <typename Factory = default_factory>
 inline std::shared_ptr<logger> syslog_logger_st(
-    const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, int syslog_facility = (1 << 3))
+    const std::string &logger_name, const std::string &syslog_ident = "",
-{
+    int syslog_option = 0, int syslog_facility = (1 << 3)) {
-    return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, syslog_facility);
+  return Factory::template create<sinks::syslog_sink_st>(
+      logger_name, syslog_ident, syslog_option, syslog_facility);
 }
 }  // namespace spdlog

src/cpp/include/deps/spdlog/sinks/wincolor_sink.h

@@ -9,16 +9,17 @@
 #include "spdlog/spdlog.h"
 #endif
 
-#include "spdlog/common.h"
+#include <wincon.h>
-#include "spdlog/details/console_globals.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/sink.h"
 
 #include <memory>
 #include <mutex>
 #include <string>
 #include <unordered_map>
-#include <wincon.h>
+
+#include "spdlog/common.h"
+#include "spdlog/details/console_globals.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/sink.h"
 
 namespace spdlog {
 namespace sinks {
@@ -27,8 +28,7 @@ namespace sinks {
  * colors
  */
 template <typename OutHandle, typename ConsoleMutex>
-class wincolor_sink : public sink
+class wincolor_sink : public sink {
-{
  public:
   const WORD BOLD = FOREGROUND_INTENSITY;
   const WORD RED = FOREGROUND_RED;
@@ -38,40 +38,33 @@ public:
   const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
 
   wincolor_sink()
-        : out_handle_(OutHandle::handle())
+      : out_handle_(OutHandle::handle()), mutex_(ConsoleMutex::mutex()) {
-        , mutex_(ConsoleMutex::mutex())
-    {
     colors_[level::trace] = WHITE;
     colors_[level::debug] = CYAN;
     colors_[level::info] = GREEN;
     colors_[level::warn] = YELLOW | BOLD;
     colors_[level::err] = RED | BOLD;  // red bold
-        colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background
+    colors_[level::critical] =
+        BACKGROUND_RED | WHITE | BOLD;  // white bold on red background
     colors_[level::off] = 0;
   }
 
-    ~wincolor_sink() override
+  ~wincolor_sink() override { this->flush(); }
-    {
-        this->flush();
-    }
 
   wincolor_sink(const wincolor_sink &other) = delete;
   wincolor_sink &operator=(const wincolor_sink &other) = delete;
 
   // change the color for the given level
-    void set_color(level::level_enum level, WORD color)
+  void set_color(level::level_enum level, WORD color) {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     colors_[level] = color;
   }
 
-    void log(const details::log_msg &msg) final override
+  void log(const details::log_msg &msg) final override {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
     fmt::memory_buffer formatted;
     formatter_->format(msg, formatted);
-        if (msg.color_range_end > msg.color_range_start)
+    if (msg.color_range_end > msg.color_range_start) {
-        {
       // before color range
       print_range_(formatted, 0, msg.color_range_start);
 
@@ -82,26 +75,24 @@ public:
                                 orig_attribs);  // reset to orig colors
                                                 // after color range
       print_range_(formatted, msg.color_range_end, formatted.size());
-        }
+    } else  // print without colors if color range is invalid
-        else // print without colors if color range is invalid
     {
       print_range_(formatted, 0, formatted.size());
     }
   }
 
-    void flush() final override
+  void flush() final override {
-    {
     // windows console always flushed?
   }
 
-    void set_pattern(const std::string &pattern) override final
+  void set_pattern(const std::string &pattern) override final {
-    {
     std::lock_guard<mutex_t> lock(mutex_);
-        formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+    formatter_ =
+        std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
   }
 
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final
+  void set_formatter(
-    {
+      std::unique_ptr<spdlog::formatter> sink_formatter) override final {
     std::lock_guard<mutex_t> lock(mutex_);
     formatter_ = std::move(sink_formatter);
   }
@@ -109,23 +100,24 @@ public:
  private:
   using mutex_t = typename ConsoleMutex::mutex_t;
   // set color and return the orig console attributes (for resetting later)
-    WORD set_console_attribs(WORD attribs)
+  WORD set_console_attribs(WORD attribs) {
-    {
     CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
     ::GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
     WORD back_color = orig_buffer_info.wAttributes;
     // retrieve the current background color
-        back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY));
+    back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN |
+                                      FOREGROUND_BLUE | FOREGROUND_INTENSITY));
     // keep the background color unchanged
     ::SetConsoleTextAttribute(out_handle_, attribs | back_color);
     return orig_buffer_info.wAttributes;  // return orig attribs
   }
 
   // print a range of formatted message to console
-    void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end)
+  void print_range_(const fmt::memory_buffer &formatted, size_t start,
-    {
+                    size_t end) {
     auto size = static_cast<DWORD>(end - start);
-        ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr);
+    ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr,
+                    nullptr);
   }
 
   HANDLE out_handle_;
@@ -133,11 +125,15 @@ private:
   std::unordered_map<level::level_enum, WORD, level::level_hasher> colors_;
 };
 
-using wincolor_stdout_sink_mt = wincolor_sink<details::console_stdout, details::console_mutex>;
+using wincolor_stdout_sink_mt =
-using wincolor_stdout_sink_st = wincolor_sink<details::console_stdout, details::console_nullmutex>;
+    wincolor_sink<details::console_stdout, details::console_mutex>;
+using wincolor_stdout_sink_st =
+    wincolor_sink<details::console_stdout, details::console_nullmutex>;
 
-using wincolor_stderr_sink_mt = wincolor_sink<details::console_stderr, details::console_mutex>;
+using wincolor_stderr_sink_mt =
-using wincolor_stderr_sink_st = wincolor_sink<details::console_stderr, details::console_nullmutex>;
+    wincolor_sink<details::console_stderr, details::console_mutex>;
+using wincolor_stderr_sink_st =
+    wincolor_sink<details::console_stderr, details::console_nullmutex>;
 
 }  // namespace sinks
 }  // namespace spdlog

src/cpp/include/deps/spdlog/spdlog.h

@@ -9,26 +9,26 @@
 #define SPDLOG_H
 #pragma once
 
-#include "spdlog/common.h"
-#include "spdlog/details/registry.h"
-#include "spdlog/logger.h"
-#include "spdlog/version.h"
-
 #include <chrono>
 #include <functional>
 #include <memory>
 #include <string>
 
+#include "spdlog/common.h"
+#include "spdlog/details/registry.h"
+#include "spdlog/logger.h"
+#include "spdlog/version.h"
+
 namespace spdlog {
 
 // Default logger factory-  creates synchronous loggers
-struct synchronous_factory
+struct synchronous_factory {
-{
   template <typename Sink, typename... SinkArgs>
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
+  static std::shared_ptr<spdlog::logger> create(std::string logger_name,
-    {
+                                                SinkArgs &&... args) {
     auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<logger>(std::move(logger_name), std::move(sink));
+    auto new_logger =
+        std::make_shared<logger>(std::move(logger_name), std::move(sink));
     details::registry::instance().initialize_logger(new_logger);
     return new_logger;
   }
@@ -40,95 +40,85 @@ using default_factory = synchronous_factory;
 // The logger's level, formatter and flush level will be set according the
 // global settings.
 // Example:
-// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
+// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11,
+// 59);
 template <typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create(std::string logger_name,
-{
+                                              SinkArgs &&... sink_args) {
-    return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+  return default_factory::create<Sink>(std::move(logger_name),
+                                       std::forward<SinkArgs>(sink_args)...);
 }
 
 // Return an existing logger or nullptr if a logger with such name doesn't
 // exist.
 // example: spdlog::get("my_logger")->info("hello {}", "world");
-inline std::shared_ptr<logger> get(const std::string &name)
+inline std::shared_ptr<logger> get(const std::string &name) {
-{
   return details::registry::instance().get(name);
 }
 
-// Set global formatter. Each sink in each logger will get a clone of this object
+// Set global formatter. Each sink in each logger will get a clone of this
-inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
+// object
-{
+inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter) {
   details::registry::instance().set_formatter(std::move(formatter));
 }
 
 // Set global format string.
 // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
-inline void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local)
+inline void set_pattern(std::string pattern, pattern_time_type time_type =
-{
+                                                 pattern_time_type::local) {
-    set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
+  set_formatter(std::unique_ptr<spdlog::formatter>(
+      new pattern_formatter(std::move(pattern), time_type)));
 }
 
 // Set global logging level
-inline void set_level(level::level_enum log_level)
+inline void set_level(level::level_enum log_level) {
-{
   details::registry::instance().set_level(log_level);
 }
 
 // Set global flush level
-inline void flush_on(level::level_enum log_level)
+inline void flush_on(level::level_enum log_level) {
-{
   details::registry::instance().flush_on(log_level);
 }
 
 // Start/Restart a periodic flusher thread
 // Warning: Use only if all your loggers are thread safe!
-inline void flush_every(std::chrono::seconds interval)
+inline void flush_every(std::chrono::seconds interval) {
-{
   details::registry::instance().flush_every(interval);
 }
 
 // Set global error handler
-inline void set_error_handler(log_err_handler handler)
+inline void set_error_handler(log_err_handler handler) {
-{
   details::registry::instance().set_error_handler(std::move(handler));
 }
 
 // Register the given logger with the given name
-inline void register_logger(std::shared_ptr<logger> logger)
+inline void register_logger(std::shared_ptr<logger> logger) {
-{
   details::registry::instance().register_logger(std::move(logger));
 }
 
 // Apply a user defined function on all registered loggers
 // Example:
 // spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
-inline void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun)
+inline void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun) {
-{
   details::registry::instance().apply_all(fun);
 }
 
 // Drop the reference to the given logger
-inline void drop(const std::string &name)
+inline void drop(const std::string &name) {
-{
   details::registry::instance().drop(name);
 }
 
 // Drop all references from the registry
-inline void drop_all()
+inline void drop_all() { details::registry::instance().drop_all(); }
-{
-    details::registry::instance().drop_all();
-}
 
 // stop any running threads started by spdlog and clean registry loggers
-inline void shutdown()
+inline void shutdown() { details::registry::instance().shutdown(); }
-{
-    details::registry::instance().shutdown();
-}
 
-// Automatic registration of loggers when using spdlog::create() or spdlog::create_async
+// Automatic registration of loggers when using spdlog::create() or
-inline void set_automatic_registration(bool automatic_registation)
+// spdlog::create_async
-{
+inline void set_automatic_registration(bool automatic_registation) {
-    details::registry::instance().set_automatic_registration(automatic_registation);
+  details::registry::instance().set_automatic_registration(
+      automatic_registation);
 }
 
 // API for using default logger (stdout_color_mt),
@@ -144,153 +134,131 @@ inline void set_automatic_registration(bool automatic_registation)
 // IMPORTANT:
 // The default API is thread safe (for _mt loggers), but:
 // set_default_logger() *should not* be used concurrently with the default API.
-// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+// e.g do not call set_default_logger() from one thread while calling
+// spdlog::info() from another.
 
-inline std::shared_ptr<spdlog::logger> default_logger()
+inline std::shared_ptr<spdlog::logger> default_logger() {
-{
   return details::registry::instance().default_logger();
 }
 
-inline spdlog::logger *default_logger_raw()
+inline spdlog::logger *default_logger_raw() {
-{
   return details::registry::instance().get_default_raw();
 }
 
-inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger)
+inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) {
-{
   details::registry::instance().set_default_logger(std::move(default_logger));
 }
 
 template <typename... Args>
-inline void log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
+inline void log(source_loc source, level::level_enum lvl, const char *fmt,
-{
+                const Args &... args) {
   default_logger_raw()->log(source, lvl, fmt, args...);
 }
 
 template <typename... Args>
-inline void log(level::level_enum lvl, const char *fmt, const Args &... args)
+inline void log(level::level_enum lvl, const char *fmt, const Args &... args) {
-{
   default_logger_raw()->log(source_loc{}, lvl, fmt, args...);
 }
 
 template <typename... Args>
-inline void trace(const char *fmt, const Args &... args)
+inline void trace(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->trace(fmt, args...);
 }
 
 template <typename... Args>
-inline void debug(const char *fmt, const Args &... args)
+inline void debug(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->debug(fmt, args...);
 }
 
 template <typename... Args>
-inline void info(const char *fmt, const Args &... args)
+inline void info(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->info(fmt, args...);
 }
 
 template <typename... Args>
-inline void warn(const char *fmt, const Args &... args)
+inline void warn(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->warn(fmt, args...);
 }
 
 template <typename... Args>
-inline void error(const char *fmt, const Args &... args)
+inline void error(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->error(fmt, args...);
 }
 
 template <typename... Args>
-inline void critical(const char *fmt, const Args &... args)
+inline void critical(const char *fmt, const Args &... args) {
-{
   default_logger_raw()->critical(fmt, args...);
 }
 
 template <typename T>
-inline void log(level::level_enum lvl, const T &msg)
+inline void log(level::level_enum lvl, const T &msg) {
-{
   default_logger_raw()->log(lvl, msg);
 }
 
 template <typename T>
-inline void trace(const T &msg)
+inline void trace(const T &msg) {
-{
   default_logger_raw()->trace(msg);
 }
 
 template <typename T>
-inline void debug(const T &msg)
+inline void debug(const T &msg) {
-{
   default_logger_raw()->debug(msg);
 }
 
 template <typename T>
-inline void info(const T &msg)
+inline void info(const T &msg) {
-{
   default_logger_raw()->info(msg);
 }
 
 template <typename T>
-inline void warn(const T &msg)
+inline void warn(const T &msg) {
-{
   default_logger_raw()->warn(msg);
 }
 
 template <typename T>
-inline void error(const T &msg)
+inline void error(const T &msg) {
-{
   default_logger_raw()->error(msg);
 }
 
 template <typename T>
-inline void critical(const T &msg)
+inline void critical(const T &msg) {
-{
   default_logger_raw()->critical(msg);
 }
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
 template <typename... Args>
-inline void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
+inline void log(level::level_enum lvl, const wchar_t *fmt,
-{
+                const Args &... args) {
   default_logger_raw()->log(lvl, fmt, args...);
 }
 
 template <typename... Args>
-inline void trace(const wchar_t *fmt, const Args &... args)
+inline void trace(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->trace(fmt, args...);
 }
 
 template <typename... Args>
-inline void debug(const wchar_t *fmt, const Args &... args)
+inline void debug(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->debug(fmt, args...);
 }
 
 template <typename... Args>
-inline void info(const wchar_t *fmt, const Args &... args)
+inline void info(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->info(fmt, args...);
 }
 
 template <typename... Args>
-inline void warn(const wchar_t *fmt, const Args &... args)
+inline void warn(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->warn(fmt, args...);
 }
 
 template <typename... Args>
-inline void error(const wchar_t *fmt, const Args &... args)
+inline void error(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->error(fmt, args...);
 }
 
 template <typename... Args>
-inline void critical(const wchar_t *fmt, const Args &... args)
+inline void critical(const wchar_t *fmt, const Args &... args) {
-{
   default_logger_raw()->critical(fmt, args...);
 }
 
@@ -313,51 +281,65 @@ inline void critical(const wchar_t *fmt, const Args &... args)
 
 #define SPDLOG_LOGGER_CALL(logger, level, ...)                             \
   if (logger->should_log(level))                                           \
-    logger->log(spdlog::source_loc{SPDLOG_FILE_BASENAME(__FILE__), __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
+  logger->log(spdlog::source_loc{SPDLOG_FILE_BASENAME(__FILE__), __LINE__, \
+                                 SPDLOG_FUNCTION},                         \
+              level, __VA_ARGS__)
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
-#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
+#define SPDLOG_LOGGER_TRACE(logger, ...) \
-#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
+#define SPDLOG_TRACE(...) \
+  SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
 #define SPDLOG_TRACE(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
-#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
+#define SPDLOG_LOGGER_DEBUG(logger, ...) \
-#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
+#define SPDLOG_DEBUG(...) \
+  SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
 #define SPDLOG_DEBUG(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
-#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
+#define SPDLOG_LOGGER_INFO(logger, ...) \
-#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
+#define SPDLOG_INFO(...) \
+  SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
 #define SPDLOG_INFO(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
-#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
+#define SPDLOG_LOGGER_WARN(logger, ...) \
-#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
+#define SPDLOG_WARN(...) \
+  SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
 #define SPDLOG_WARN(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
-#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
+#define SPDLOG_LOGGER_ERROR(logger, ...) \
-#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
+#define SPDLOG_ERROR(...) \
+  SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
 #define SPDLOG_ERROR(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
-#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
+#define SPDLOG_LOGGER_CRITICAL(logger, ...) \
-#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
+  SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
+#define SPDLOG_CRITICAL(...) \
+  SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
 #define SPDLOG_CRITICAL(...) (void)0

src/cpp/include/deps/spdlog/tweakme.h

@@ -123,14 +123,16 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to disable default logger creation.
-// This might save some (very) small initialization time if no default logger is needed.
+// This might save some (very) small initialization time if no default logger is
+// needed.
 //
 // #define SPDLOG_DISABLE_DEFAULT_LOGGER
 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment and set to compile time level with zero cost (default is INFO).
-// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..)  will expand to empty statements if not enabled
+// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..)  will expand to empty
+// statements if not enabled
 //
 // #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 ///////////////////////////////////////////////////////////////////////////////

src/cpp/include/deps/spdlog/version.h

@@ -9,4 +9,5 @@
 #define SPDLOG_VER_MINOR 3
 #define SPDLOG_VER_PATCH 1
 
-#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)
+#define SPDLOG_VERSION \
+  (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)

src/cpp/include/deps/yoga/Bitfield.h

@@ -6,10 +6,11 @@
  */
 #pragma once
 
+#include <yoga/YGEnums.h>
+
 #include <cstddef>
 #include <limits>
 #include <type_traits>
-#include <yoga/YGEnums.h>
 
 namespace facebook {
 namespace yoga {
@@ -23,8 +24,8 @@ constexpr size_t log2ceil(size_t n) {
 // The number of bits necessary to represent enums defined with YG_ENUM_SEQ_DECL
 template <typename Enum>
 constexpr size_t bitWidth() {
-  static_assert(
+  static_assert(enums::count<Enum>() > 0,
-      enums::count<Enum>() > 0, "Enums must have at least one entries");
+                "Enums must have at least one entries");
   return log2ceil(enums::count<Enum>() - 1);
 }
 
@@ -75,19 +76,16 @@ struct IndexedType<0, T, Ts...> {
 
 template <typename Storage, typename... Fields>
 class Bitfield {
-  static_assert(
+  static_assert(std::is_integral<Storage>::value,
-      std::is_integral<Storage>::value,
                 "Bitfield needs an integral storage type");
-  static_assert(
+  static_assert(std::is_unsigned<Storage>::value,
-      std::is_unsigned<Storage>::value,
                 "Bitfield needs an unsigned storage type");
   static_assert(sizeof...(Fields) > 0, "Bitfield needs at least one member");
 
   using BitTraits = detail::BitTraits<Storage, Fields...>;
 
 #if !defined(_MSC_VER) || _MSC_VER > 1914
-  static_assert(
+  static_assert(BitTraits::shift(0) + BitTraits::width(0) <=
-      BitTraits::shift(0) + BitTraits::width(0) <=
                     std::numeric_limits<Storage>::digits,
                 "Specified storage type is too narrow to hold all types");
 #endif
@@ -116,7 +114,8 @@ public:
    public:
     Ref(Bitfield& bitfield) : bitfield_(bitfield) {}
     Ref& operator=(TypeAt<Idx> value) {
-      bitfield_.storage_ = (bitfield_.storage_ & ~BitTraits::mask(Idx)) |
+      bitfield_.storage_ =
+          (bitfield_.storage_ & ~BitTraits::mask(Idx)) |
           ((value << BitTraits::shift(Idx)) & BitTraits::mask(Idx));
       return *this;
     }
@@ -130,8 +129,8 @@ public:
 
   template <size_t Idx>
   constexpr TypeAt<Idx> at() const {
-    return static_cast<TypeAt<Idx>>(
+    return static_cast<TypeAt<Idx>>((storage_ & BitTraits::mask(Idx)) >>
-        (storage_ & BitTraits::mask(Idx)) >> BitTraits::shift(Idx));
+                                    BitTraits::shift(Idx));
   }
 
   template <size_t Idx>

src/cpp/include/deps/yoga/CompactValue.h

@@ -6,12 +6,12 @@
  */
 #pragma once
 
-#include "YGValue.h"
-
 #include <cmath>
 #include <cstdint>
 #include <limits>
 
+#include "YGValue.h"
+
 static_assert(
     std::numeric_limits<float>::is_iec559,
     "facebook::yoga::detail::CompactValue only works with IEEE754 floats");
@@ -129,8 +129,7 @@ public:
   }
 
   bool isUndefined() const noexcept {
-    return (
+    return (payload_.repr != AUTO_BITS && payload_.repr != ZERO_BITS_POINT &&
-        payload_.repr != AUTO_BITS && payload_.repr != ZERO_BITS_POINT &&
             payload_.repr != ZERO_BITS_PERCENT && std::isnan(payload_.value));
   }
 

src/cpp/include/deps/yoga/Utils.cpp

@@ -8,8 +8,7 @@
 
 using namespace facebook;
 
-YGFlexDirection YGFlexDirectionCross(
+YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
-    const YGFlexDirection flexDirection,
                                      const YGDirection direction) {
   return YGFlexDirectionIsColumn(flexDirection)
              ? YGResolveFlexDirection(YGFlexDirectionRow, direction)

src/cpp/include/deps/yoga/Utils.h

@@ -5,9 +5,9 @@
  * file in the root directory of this source tree.
  */
 #pragma once
+#include "CompactValue.h"
 #include "YGNode.h"
 #include "Yoga-internal.h"
-#include "CompactValue.h"
 
 // This struct is an helper model to hold the data for step 4 of flexbox algo,
 // which is collecting the flex items in a line.
@@ -53,8 +53,7 @@ struct YGCollectFlexItemsRowValues {
 };
 
 bool YGValueEqual(const YGValue& a, const YGValue& b);
-inline bool YGValueEqual(
+inline bool YGValueEqual(facebook::yoga::detail::CompactValue a,
-    facebook::yoga::detail::CompactValue a,
                          facebook::yoga::detail::CompactValue b) {
   return YGValueEqual((YGValue)a, (YGValue)b);
 }
@@ -65,8 +64,7 @@ bool YGFloatsEqual(const float a, const float b);
 
 float YGFloatMax(const float a, const float b);
 
-YGFloatOptional YGFloatOptionalMax(
+YGFloatOptional YGFloatOptionalMax(const YGFloatOptional op1,
-    const YGFloatOptional op1,
                                    const YGFloatOptional op2);
 
 float YGFloatMin(const float a, const float b);
@@ -75,8 +73,7 @@ float YGFloatMin(const float a, const float b);
 // YGFloatsEqual, as the default float comparison operator will not work(Look
 // at the comments of YGFloatsEqual function).
 template <std::size_t size>
-bool YGFloatArrayEqual(
+bool YGFloatArrayEqual(const std::array<float, size>& val1,
-    const std::array<float, size>& val1,
                        const std::array<float, size>& val2) {
   bool areEqual = true;
   for (std::size_t i = 0; i < size && areEqual; ++i) {
@@ -88,8 +85,7 @@ bool YGFloatArrayEqual(
 // This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
 float YGFloatSanitize(const float val);
 
-YGFlexDirection YGFlexDirectionCross(
+YGFlexDirection YGFlexDirectionCross(const YGFlexDirection flexDirection,
-    const YGFlexDirection flexDirection,
                                      const YGDirection direction);
 
 inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
@@ -97,8 +93,7 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
          flexDirection == YGFlexDirectionRowReverse;
 }
 
-inline YGFloatOptional YGResolveValue(
+inline YGFloatOptional YGResolveValue(const YGValue value,
-    const YGValue value,
                                       const float ownerSize) {
   switch (value.unit) {
     case YGUnitPoint:
@@ -110,8 +105,7 @@ inline YGFloatOptional YGResolveValue(
   }
 }
 
-inline YGFloatOptional YGResolveValue(
+inline YGFloatOptional YGResolveValue(yoga::detail::CompactValue value,
-    yoga::detail::CompactValue value,
                                       float ownerSize) {
   return YGResolveValue((YGValue)value, ownerSize);
 }
@@ -122,8 +116,7 @@ inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
 }
 
 inline YGFlexDirection YGResolveFlexDirection(
-    const YGFlexDirection flexDirection,
+    const YGFlexDirection flexDirection, const YGDirection direction) {
-    const YGDirection direction) {
   if (direction == YGDirectionRTL) {
     if (flexDirection == YGFlexDirectionRow) {
       return YGFlexDirectionRowReverse;
@@ -135,8 +128,7 @@ inline YGFlexDirection YGResolveFlexDirection(
   return flexDirection;
 }
 
-inline YGFloatOptional YGResolveValueMargin(
+inline YGFloatOptional YGResolveValueMargin(yoga::detail::CompactValue value,
-    yoga::detail::CompactValue value,
                                             const float ownerSize) {
   return value.isAuto() ? YGFloatOptional{0} : YGResolveValue(value, ownerSize);
 }

src/cpp/include/deps/yoga/YGConfig.cpp

@@ -11,13 +11,8 @@ YGConfig::YGConfig(YGLogger logger) : cloneNodeCallback_{nullptr} {
   loggerUsesContext_ = false;
 }
 
-void YGConfig::log(
+void YGConfig::log(YGConfig* config, YGNode* node, YGLogLevel logLevel,
-    YGConfig* config,
+                   void* logContext, const char* format, va_list args) {
-    YGNode* node,
-    YGLogLevel logLevel,
-    void* logContext,
-    const char* format,
-    va_list args) {
   if (loggerUsesContext_) {
     logger_.withContext(config, node, logLevel, logContext, format, args);
   } else {
@@ -25,15 +20,13 @@ void YGConfig::log(
   }
 }
 
-YGNodeRef YGConfig::cloneNode(
+YGNodeRef YGConfig::cloneNode(YGNodeRef node, YGNodeRef owner, int childIndex,
-    YGNodeRef node,
-    YGNodeRef owner,
-    int childIndex,
                               void* cloneContext) {
   YGNodeRef clone = nullptr;
   if (cloneNodeCallback_.noContext != nullptr) {
     clone = cloneNodeUsesContext_
-        ? cloneNodeCallback_.withContext(node, owner, childIndex, cloneContext)
+                ? cloneNodeCallback_.withContext(node, owner, childIndex,
+                                                 cloneContext)
                 : cloneNodeCallback_.noContext(node, owner, childIndex);
   }
   if (clone == nullptr) {

src/cpp/include/deps/yoga/YGConfig.h

@@ -9,18 +9,11 @@
 #include "Yoga.h"
 
 struct YGConfig {
-  using LogWithContextFn = int (*)(
+  using LogWithContextFn = int (*)(YGConfigRef config, YGNodeRef node,
-      YGConfigRef config,
+                                   YGLogLevel level, void* context,
-      YGNodeRef node,
+                                   const char* format, va_list args);
-      YGLogLevel level,
+  using CloneWithContextFn = YGNodeRef (*)(YGNodeRef node, YGNodeRef owner,
-      void* context,
+                                           int childIndex, void* cloneContext);
-      const char* format,
-      va_list args);
-  using CloneWithContextFn = YGNodeRef (*)(
-      YGNodeRef node,
-      YGNodeRef owner,
-      int childIndex,
-      void* cloneContext);
 
  private:
   union {
@@ -56,10 +49,7 @@ public:
   }
   void setLogger(std::nullptr_t) { setLogger(YGLogger{nullptr}); }
 
-  YGNodeRef cloneNode(
+  YGNodeRef cloneNode(YGNodeRef node, YGNodeRef owner, int childIndex,
-      YGNodeRef node,
-      YGNodeRef owner,
-      int childIndex,
                       void* cloneContext);
   void setCloneNodeCallback(YGCloneNodeFunc cloneNode) {
     cloneNodeCallback_.noContext = cloneNode;

src/cpp/include/deps/yoga/YGEnums.h

@@ -53,93 +53,48 @@ constexpr int n() {
 
 YG_EXTERN_C_BEGIN
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGAlign, YGAlignAuto, YGAlignFlexStart, YGAlignCenter,
-    YGAlign,
+                 YGAlignFlexEnd, YGAlignStretch, YGAlignBaseline,
-    YGAlignAuto,
+                 YGAlignSpaceBetween, YGAlignSpaceAround);
-    YGAlignFlexStart,
-    YGAlignCenter,
-    YGAlignFlexEnd,
-    YGAlignStretch,
-    YGAlignBaseline,
-    YGAlignSpaceBetween,
-    YGAlignSpaceAround);
 
 YG_ENUM_SEQ_DECL(YGDimension, YGDimensionWidth, YGDimensionHeight)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGDirection, YGDirectionInherit, YGDirectionLTR,
-    YGDirection,
-    YGDirectionInherit,
-    YGDirectionLTR,
                  YGDirectionRTL)
 
 YG_ENUM_SEQ_DECL(YGDisplay, YGDisplayFlex, YGDisplayNone)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGEdge, YGEdgeLeft, YGEdgeTop, YGEdgeRight, YGEdgeBottom,
-    YGEdge,
+                 YGEdgeStart, YGEdgeEnd, YGEdgeHorizontal, YGEdgeVertical,
-    YGEdgeLeft,
-    YGEdgeTop,
-    YGEdgeRight,
-    YGEdgeBottom,
-    YGEdgeStart,
-    YGEdgeEnd,
-    YGEdgeHorizontal,
-    YGEdgeVertical,
                  YGEdgeAll)
 
 YG_ENUM_SEQ_DECL(YGExperimentalFeature, YGExperimentalFeatureWebFlexBasis)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGFlexDirection, YGFlexDirectionColumn,
-    YGFlexDirection,
+                 YGFlexDirectionColumnReverse, YGFlexDirectionRow,
-    YGFlexDirectionColumn,
-    YGFlexDirectionColumnReverse,
-    YGFlexDirectionRow,
                  YGFlexDirectionRowReverse)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGJustify, YGJustifyFlexStart, YGJustifyCenter,
-    YGJustify,
+                 YGJustifyFlexEnd, YGJustifySpaceBetween, YGJustifySpaceAround,
-    YGJustifyFlexStart,
-    YGJustifyCenter,
-    YGJustifyFlexEnd,
-    YGJustifySpaceBetween,
-    YGJustifySpaceAround,
                  YGJustifySpaceEvenly)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGLogLevel, YGLogLevelError, YGLogLevelWarn, YGLogLevelInfo,
-    YGLogLevel,
+                 YGLogLevelDebug, YGLogLevelVerbose, YGLogLevelFatal)
-    YGLogLevelError,
-    YGLogLevelWarn,
-    YGLogLevelInfo,
-    YGLogLevelDebug,
-    YGLogLevelVerbose,
-    YGLogLevelFatal)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGMeasureMode, YGMeasureModeUndefined, YGMeasureModeExactly,
-    YGMeasureMode,
-    YGMeasureModeUndefined,
-    YGMeasureModeExactly,
                  YGMeasureModeAtMost)
 
 YG_ENUM_SEQ_DECL(YGNodeType, YGNodeTypeDefault, YGNodeTypeText)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGOverflow, YGOverflowVisible, YGOverflowHidden,
-    YGOverflow,
-    YGOverflowVisible,
-    YGOverflowHidden,
                  YGOverflowScroll)
 
 YG_ENUM_SEQ_DECL(YGPositionType, YGPositionTypeRelative, YGPositionTypeAbsolute)
 
-YG_ENUM_DECL(
+YG_ENUM_DECL(YGPrintOptions, YGPrintOptionsLayout = 1, YGPrintOptionsStyle = 2,
-    YGPrintOptions,
-    YGPrintOptionsLayout = 1,
-    YGPrintOptionsStyle = 2,
              YGPrintOptionsChildren = 4)
 
-YG_ENUM_SEQ_DECL(
+YG_ENUM_SEQ_DECL(YGUnit, YGUnitUndefined, YGUnitPoint, YGUnitPercent,
-    YGUnit,
-    YGUnitUndefined,
-    YGUnitPoint,
-    YGUnitPercent,
                  YGUnitAuto)
 
 YG_ENUM_SEQ_DECL(YGWrap, YGWrapNoWrap, YGWrapWrap, YGWrapWrapReverse)

src/cpp/include/deps/yoga/YGFloatOptional.h

@@ -8,6 +8,7 @@
 
 #include <cmath>
 #include <limits>
+
 #include "Yoga-internal.h"
 
 struct YGFloatOptional {
@@ -37,16 +38,10 @@ inline bool operator!=(YGFloatOptional lhs, YGFloatOptional rhs) {
 inline bool operator==(YGFloatOptional lhs, float rhs) {
   return lhs == YGFloatOptional{rhs};
 }
-inline bool operator!=(YGFloatOptional lhs, float rhs) {
+inline bool operator!=(YGFloatOptional lhs, float rhs) { return !(lhs == rhs); }
-  return !(lhs == rhs);
-}
 
-inline bool operator==(float lhs, YGFloatOptional rhs) {
+inline bool operator==(float lhs, YGFloatOptional rhs) { return rhs == lhs; }
-  return rhs == lhs;
+inline bool operator!=(float lhs, YGFloatOptional rhs) { return !(lhs == rhs); }
-}
-inline bool operator!=(float lhs, YGFloatOptional rhs) {
-  return !(lhs == rhs);
-}
 
 inline YGFloatOptional operator+(YGFloatOptional lhs, YGFloatOptional rhs) {
   return YGFloatOptional{lhs.unwrap() + rhs.unwrap()};

src/cpp/include/deps/yoga/YGLayout.cpp

@@ -5,12 +5,14 @@
  * file in the root directory of this source tree.
  */
 #include "YGLayout.h"
+
 #include "Utils.h"
 
 using namespace facebook;
 
 bool YGLayout::operator==(YGLayout layout) const {
-  bool isEqual = YGFloatArrayEqual(position, layout.position) &&
+  bool isEqual =
+      YGFloatArrayEqual(position, layout.position) &&
       YGFloatArrayEqual(dimensions, layout.dimensions) &&
       YGFloatArrayEqual(margin, layout.margin) &&
       YGFloatArrayEqual(border, layout.border) &&

src/cpp/include/deps/yoga/YGLayout.h

@@ -21,8 +21,8 @@ private:
   static constexpr size_t didUseLegacyFlagIdx = 1;
   static constexpr size_t doesLegacyStretchFlagAffectsLayoutIdx = 2;
   static constexpr size_t hadOverflowIdx = 3;
-  facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ =
+  facebook::yoga::Bitfield<uint8_t, YGDirection, bool, bool, bool> flags_ = {
-      {YGDirectionInherit, false, false, false};
+      YGDirectionInherit, false, false, false};
 
  public:
   uint32_t computedFlexBasisGeneration = 0;

src/cpp/include/deps/yoga/YGNode.cpp

@@ -5,8 +5,10 @@
  * file in the root directory of this source tree.
  */
 #include "YGNode.h"
+
 #include <algorithm>
 #include <iostream>
+
 #include "CompactValue.h"
 #include "Utils.h"
 
@@ -49,38 +51,36 @@ void YGNode::print(void* printContext) {
   }
 }
 
-YGFloatOptional YGNode::getLeadingPosition(
+YGFloatOptional YGNode::getLeadingPosition(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                            const float axisSize) const {
   if (YGFlexDirectionIsRow(axis)) {
-    auto leadingPosition = YGComputedEdgeValue(
+    auto leadingPosition = YGComputedEdgeValue(style_.position(), YGEdgeStart,
-        style_.position(), YGEdgeStart, CompactValue::ofUndefined());
+                                               CompactValue::ofUndefined());
     if (!leadingPosition.isUndefined()) {
       return YGResolveValue(leadingPosition, axisSize);
     }
   }
 
-  auto leadingPosition = YGComputedEdgeValue(
+  auto leadingPosition = YGComputedEdgeValue(style_.position(), leading[axis],
-      style_.position(), leading[axis], CompactValue::ofUndefined());
+                                             CompactValue::ofUndefined());
 
   return leadingPosition.isUndefined()
              ? YGFloatOptional{0}
              : YGResolveValue(leadingPosition, axisSize);
 }
 
-YGFloatOptional YGNode::getTrailingPosition(
+YGFloatOptional YGNode::getTrailingPosition(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                             const float axisSize) const {
   if (YGFlexDirectionIsRow(axis)) {
-    auto trailingPosition = YGComputedEdgeValue(
+    auto trailingPosition = YGComputedEdgeValue(style_.position(), YGEdgeEnd,
-        style_.position(), YGEdgeEnd, CompactValue::ofUndefined());
+                                                CompactValue::ofUndefined());
     if (!trailingPosition.isUndefined()) {
       return YGResolveValue(trailingPosition, axisSize);
     }
   }
 
-  auto trailingPosition = YGComputedEdgeValue(
+  auto trailingPosition = YGComputedEdgeValue(style_.position(), trailing[axis],
-      style_.position(), trailing[axis], CompactValue::ofUndefined());
+                                              CompactValue::ofUndefined());
 
   return trailingPosition.isUndefined()
              ? YGFloatOptional{0}
@@ -89,26 +89,25 @@ YGFloatOptional YGNode::getTrailingPosition(
 
 bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) const {
   return (YGFlexDirectionIsRow(axis) &&
-          !YGComputedEdgeValue(
+          !YGComputedEdgeValue(style_.position(), YGEdgeStart,
-               style_.position(), YGEdgeStart, CompactValue::ofUndefined())
+                               CompactValue::ofUndefined())
                .isUndefined()) ||
-      !YGComputedEdgeValue(
+         !YGComputedEdgeValue(style_.position(), leading[axis],
-           style_.position(), leading[axis], CompactValue::ofUndefined())
+                              CompactValue::ofUndefined())
               .isUndefined();
 }
 
 bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) const {
   return (YGFlexDirectionIsRow(axis) &&
-          !YGComputedEdgeValue(
+          !YGComputedEdgeValue(style_.position(), YGEdgeEnd,
-               style_.position(), YGEdgeEnd, CompactValue::ofUndefined())
+                               CompactValue::ofUndefined())
                .isUndefined()) ||
-      !YGComputedEdgeValue(
+         !YGComputedEdgeValue(style_.position(), trailing[axis],
-           style_.position(), trailing[axis], CompactValue::ofUndefined())
+                              CompactValue::ofUndefined())
               .isUndefined();
 }
 
-YGFloatOptional YGNode::getLeadingMargin(
+YGFloatOptional YGNode::getLeadingMargin(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                          const float widthSize) const {
   if (YGFlexDirectionIsRow(axis) &&
       !style_.margin()[YGEdgeStart].isUndefined()) {
@@ -116,40 +115,33 @@ YGFloatOptional YGNode::getLeadingMargin(
   }
 
   return YGResolveValueMargin(
-      YGComputedEdgeValue(
+      YGComputedEdgeValue(style_.margin(), leading[axis],
-          style_.margin(), leading[axis], CompactValue::ofZero()),
+                          CompactValue::ofZero()),
       widthSize);
 }
 
-YGFloatOptional YGNode::getTrailingMargin(
+YGFloatOptional YGNode::getTrailingMargin(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                           const float widthSize) const {
   if (YGFlexDirectionIsRow(axis) && !style_.margin()[YGEdgeEnd].isUndefined()) {
     return YGResolveValueMargin(style_.margin()[YGEdgeEnd], widthSize);
   }
 
   return YGResolveValueMargin(
-      YGComputedEdgeValue(
+      YGComputedEdgeValue(style_.margin(), trailing[axis],
-          style_.margin(), trailing[axis], CompactValue::ofZero()),
+                          CompactValue::ofZero()),
       widthSize);
 }
 
-YGFloatOptional YGNode::getMarginForAxis(
+YGFloatOptional YGNode::getMarginForAxis(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                          const float widthSize) const {
   return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
 }
 
-YGSize YGNode::measure(
+YGSize YGNode::measure(float width, YGMeasureMode widthMode, float height,
-    float width,
+                       YGMeasureMode heightMode, void* layoutContext) {
-    YGMeasureMode widthMode,
-    float height,
-    YGMeasureMode heightMode,
-    void* layoutContext) {
-
   return flags_.at<measureUsesContext_>()
-      ? measure_.withContext(
+             ? measure_.withContext(this, width, widthMode, height, heightMode,
-            this, width, widthMode, height, heightMode, layoutContext)
+                                    layoutContext)
              : measure_.noContext(this, width, widthMode, height, heightMode);
 }
 
@@ -168,8 +160,7 @@ void YGNode::setMeasureFunc(decltype(YGNode::measure_) measureFunc) {
     flags_.at<nodeType_>() = YGNodeTypeDefault;
   } else {
     YGAssertWithNode(
-        this,
+        this, children_.size() == 0,
-        children_.size() == 0,
         "Cannot set measure function: Nodes with measure functions cannot have "
         "children.");
     // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
@@ -278,8 +269,7 @@ void YGNode::setLayoutDimension(float dimension, int index) {
 
 // If both left and right are defined, then use left. Otherwise return +left or
 // -right depending on which is defined.
-YGFloatOptional YGNode::relativePosition(
+YGFloatOptional YGNode::relativePosition(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                          const float axisSize) const {
   if (isLeadingPositionDefined(axis)) {
     return getLeadingPosition(axis, axisSize);
@@ -292,11 +282,8 @@ YGFloatOptional YGNode::relativePosition(
   return trailingPosition;
 }
 
-void YGNode::setPosition(
+void YGNode::setPosition(const YGDirection direction, const float mainSize,
-    const YGDirection direction,
+                         const float crossSize, const float ownerWidth) {
-    const float mainSize,
-    const float crossSize,
-    const float ownerWidth) {
   /* Root nodes should be always layouted as LTR, so we don't return negative
    * values. */
   const YGDirection directionRespectingRoot =
@@ -435,8 +422,7 @@ float YGNode::resolveFlexShrink() const {
 }
 
 bool YGNode::isNodeFlexible() {
-  return (
+  return ((style_.positionType() == YGPositionTypeRelative) &&
-      (style_.positionType() == YGPositionTypeRelative) &&
           (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
 }
 
@@ -450,8 +436,8 @@ float YGNode::getLeadingBorder(const YGFlexDirection axis) const {
     }
   }
 
-  leadingBorder = YGComputedEdgeValue(
+  leadingBorder = YGComputedEdgeValue(style_.border(), leading[axis],
-      style_.border(), leading[axis], CompactValue::ofZero());
+                                      CompactValue::ofZero());
   return YGFloatMax(leadingBorder.value, 0.0f);
 }
 
@@ -465,13 +451,12 @@ float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) const {
     }
   }
 
-  trailingBorder = YGComputedEdgeValue(
+  trailingBorder = YGComputedEdgeValue(style_.border(), trailing[flexDirection],
-      style_.border(), trailing[flexDirection], CompactValue::ofZero());
+                                       CompactValue::ofZero());
   return YGFloatMax(trailingBorder.value, 0.0f);
 }
 
-YGFloatOptional YGNode::getLeadingPadding(
+YGFloatOptional YGNode::getLeadingPadding(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                           const float widthSize) const {
   const YGFloatOptional paddingEdgeStart =
       YGResolveValue(style_.padding()[YGEdgeStart], widthSize);
@@ -481,15 +466,14 @@ YGFloatOptional YGNode::getLeadingPadding(
     return paddingEdgeStart;
   }
 
-  YGFloatOptional resolvedValue = YGResolveValue(
+  YGFloatOptional resolvedValue =
-      YGComputedEdgeValue(
+      YGResolveValue(YGComputedEdgeValue(style_.padding(), leading[axis],
-          style_.padding(), leading[axis], CompactValue::ofZero()),
+                                         CompactValue::ofZero()),
                      widthSize);
   return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
 }
 
-YGFloatOptional YGNode::getTrailingPadding(
+YGFloatOptional YGNode::getTrailingPadding(const YGFlexDirection axis,
-    const YGFlexDirection axis,
                                            const float widthSize) const {
   const YGFloatOptional paddingEdgeEnd =
       YGResolveValue(style_.padding()[YGEdgeEnd], widthSize);
@@ -497,24 +481,22 @@ YGFloatOptional YGNode::getTrailingPadding(
     return paddingEdgeEnd;
   }
 
-  YGFloatOptional resolvedValue = YGResolveValue(
+  YGFloatOptional resolvedValue =
-      YGComputedEdgeValue(
+      YGResolveValue(YGComputedEdgeValue(style_.padding(), trailing[axis],
-          style_.padding(), trailing[axis], CompactValue::ofZero()),
+                                         CompactValue::ofZero()),
                      widthSize);
 
   return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
 }
 
 YGFloatOptional YGNode::getLeadingPaddingAndBorder(
-    const YGFlexDirection axis,
+    const YGFlexDirection axis, const float widthSize) const {
-    const float widthSize) const {
   return getLeadingPadding(axis, widthSize) +
          YGFloatOptional(getLeadingBorder(axis));
 }
 
 YGFloatOptional YGNode::getTrailingPaddingAndBorder(
-    const YGFlexDirection axis,
+    const YGFlexDirection axis, const float widthSize) const {
-    const float widthSize) const {
   return getTrailingPadding(axis, widthSize) +
          YGFloatOptional(getTrailingBorder(axis));
 }
@@ -567,12 +549,10 @@ bool YGNode::isLayoutTreeEqualToNode(const YGNode& node) const {
 }
 
 void YGNode::reset() {
-  YGAssertWithNode(
+  YGAssertWithNode(this, children_.size() == 0,
-      this,
-      children_.size() == 0,
                    "Cannot reset a node which still has children attached");
-  YGAssertWithNode(
+  YGAssertWithNode(this, owner_ == nullptr,
-      this, owner_ == nullptr, "Cannot reset a node still attached to a owner");
+                   "Cannot reset a node still attached to a owner");
 
   clearChildren();
 

src/cpp/include/deps/yoga/YGNode.h

@@ -5,21 +5,23 @@
  * file in the root directory of this source tree.
  */
 #pragma once
-#include <cstdint>
 #include <stdio.h>
+
+#include <cstdint>
+
 #include "Bitfield.h"
 #include "CompactValue.h"
 #include "YGConfig.h"
 #include "YGLayout.h"
-#include "YGStyle.h"
 #include "YGMacros.h"
+#include "YGStyle.h"
 #include "Yoga-internal.h"
 
 YGConfigRef YGConfigGetDefault();
 
 struct YGNode {
-  using MeasureWithContextFn =
+  using MeasureWithContextFn = YGSize (*)(YGNode*, float, YGMeasureMode, float,
-      YGSize (*)(YGNode*, float, YGMeasureMode, float, YGMeasureMode, void*);
+                                          YGMeasureMode, void*);
   using BaselineWithContextFn = float (*)(YGNode*, float, float, void*);
   using PrintWithContextFn = void (*)(YGNode*, void*);
 
@@ -34,10 +36,10 @@ private:
   static constexpr size_t useWebDefaults_ = 7;
 
   void* context_ = nullptr;
-  using Flags = facebook::yoga::
+  using Flags = facebook::yoga::Bitfield<uint8_t, bool, bool, bool, YGNodeType,
-      Bitfield<uint8_t, bool, bool, bool, YGNodeType, bool, bool, bool, bool>;
+                                         bool, bool, bool, bool>;
-  Flags flags_ =
+  Flags flags_ = {true,  false, false, YGNodeTypeDefault,
-      {true, false, false, YGNodeTypeDefault, false, false, false, false};
+                  false, false, false, false};
   uint8_t reserved_ = 0;
   union {
     YGMeasureFunc noContext;
@@ -61,8 +63,7 @@ private:
   std::array<YGValue, 2> resolvedDimensions_ = {
       {YGValueUndefined, YGValueUndefined}};
 
-  YGFloatOptional relativePosition(
+  YGFloatOptional relativePosition(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                    const float axisSize) const;
 
   void setMeasureFunc(decltype(measure_));
@@ -185,36 +186,27 @@ public:
   }
 
   // Methods related to positions, margin, padding and border
-  YGFloatOptional getLeadingPosition(
+  YGFloatOptional getLeadingPosition(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                      const float axisSize) const;
   bool isLeadingPositionDefined(const YGFlexDirection axis) const;
   bool isTrailingPosDefined(const YGFlexDirection axis) const;
-  YGFloatOptional getTrailingPosition(
+  YGFloatOptional getTrailingPosition(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                       const float axisSize) const;
-  YGFloatOptional getLeadingMargin(
+  YGFloatOptional getLeadingMargin(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                    const float widthSize) const;
-  YGFloatOptional getTrailingMargin(
+  YGFloatOptional getTrailingMargin(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                     const float widthSize) const;
   float getLeadingBorder(const YGFlexDirection flexDirection) const;
   float getTrailingBorder(const YGFlexDirection flexDirection) const;
-  YGFloatOptional getLeadingPadding(
+  YGFloatOptional getLeadingPadding(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                     const float widthSize) const;
-  YGFloatOptional getTrailingPadding(
+  YGFloatOptional getTrailingPadding(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                      const float widthSize) const;
-  YGFloatOptional getLeadingPaddingAndBorder(
+  YGFloatOptional getLeadingPaddingAndBorder(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                              const float widthSize) const;
-  YGFloatOptional getTrailingPaddingAndBorder(
+  YGFloatOptional getTrailingPaddingAndBorder(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                               const float widthSize) const;
-  YGFloatOptional getMarginForAxis(
+  YGFloatOptional getMarginForAxis(const YGFlexDirection axis,
-      const YGFlexDirection axis,
                                    const float widthSize) const;
   // Setters
 
@@ -287,11 +279,8 @@ public:
   void setLayoutBorder(float border, int index);
   void setLayoutPadding(float padding, int index);
   void setLayoutPosition(float position, int index);
-  void setPosition(
+  void setPosition(const YGDirection direction, const float mainSize,
-      const YGDirection direction,
+                   const float crossSize, const float ownerWidth);
-      const float mainSize,
-      const float crossSize,
-      const float ownerWidth);
   void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout);
   void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag);
   void markDirtyAndPropogateDownwards();

src/cpp/include/deps/yoga/YGNodePrint.cpp

@@ -6,11 +6,13 @@
  */
 #ifdef DEBUG
 #include "YGNodePrint.h"
+
 #include <stdarg.h>
+
+#include "Utils.h"
 #include "YGEnums.h"
 #include "YGNode.h"
 #include "Yoga-internal.h"
-#include "Utils.h"
 
 namespace facebook {
 namespace yoga {
@@ -40,42 +42,34 @@ static void appendFormatedString(string& str, const char* fmt, ...) {
   str.append(result);
 }
 
-static void appendFloatOptionalIfDefined(
+static void appendFloatOptionalIfDefined(string& base, const string key,
-    string& base,
-    const string key,
                                          const YGFloatOptional num) {
   if (!num.isUndefined()) {
     appendFormatedString(base, "%s: %g; ", key.c_str(), num.unwrap());
   }
 }
 
-static void appendNumberIfNotUndefined(
+static void appendNumberIfNotUndefined(string& base, const string key,
-    string& base,
-    const string key,
                                        const YGValue number) {
   if (number.unit != YGUnitUndefined) {
     if (number.unit == YGUnitAuto) {
       base.append(key + ": auto; ");
     } else {
       string unit = number.unit == YGUnitPoint ? "px" : "%%";
-      appendFormatedString(
+      appendFormatedString(base, "%s: %g%s; ", key.c_str(), number.value,
-          base, "%s: %g%s; ", key.c_str(), number.value, unit.c_str());
+                           unit.c_str());
     }
   }
 }
 
-static void appendNumberIfNotAuto(
+static void appendNumberIfNotAuto(string& base, const string& key,
-    string& base,
-    const string& key,
                                   const YGValue number) {
   if (number.unit != YGUnitAuto) {
     appendNumberIfNotUndefined(base, key, number);
   }
 }
 
-static void appendNumberIfNotZero(
+static void appendNumberIfNotZero(string& base, const string& str,
-    string& base,
-    const string& str,
                                   const YGValue number) {
   if (number.unit == YGUnitAuto) {
     base.append(str + ": auto; ");
@@ -84,9 +78,7 @@ static void appendNumberIfNotZero(
   }
 }
 
-static void appendEdges(
+static void appendEdges(string& base, const string& key,
-    string& base,
-    const string& key,
                         const YGStyle::Edges& edges) {
   if (areFourValuesEqual(edges)) {
     appendNumberIfNotZero(base, key, edges[YGEdgeLeft]);
@@ -98,35 +90,29 @@ static void appendEdges(
   }
 }
 
-static void appendEdgeIfNotUndefined(
+static void appendEdgeIfNotUndefined(string& base, const string& str,
-    string& base,
-    const string& str,
                                      const YGStyle::Edges& edges,
                                      const YGEdge edge) {
   appendNumberIfNotUndefined(
-      base,
+      base, str,
-      str,
       YGComputedEdgeValue(edges, edge, detail::CompactValue::ofUndefined()));
 }
 
-void YGNodeToString(
+void YGNodeToString(std::string& str, YGNodeRef node, YGPrintOptions options,
-    std::string& str,
-    YGNodeRef node,
-    YGPrintOptions options,
                     uint32_t level) {
   indent(str, level);
   appendFormatedString(str, "<div ");
 
   if (options & YGPrintOptionsLayout) {
     appendFormatedString(str, "layout=\"");
-    appendFormatedString(
+    appendFormatedString(str, "width: %g; ",
-        str, "width: %g; ", node->getLayout().dimensions[YGDimensionWidth]);
+                         node->getLayout().dimensions[YGDimensionWidth]);
-    appendFormatedString(
+    appendFormatedString(str, "height: %g; ",
-        str, "height: %g; ", node->getLayout().dimensions[YGDimensionHeight]);
+                         node->getLayout().dimensions[YGDimensionHeight]);
-    appendFormatedString(
+    appendFormatedString(str, "top: %g; ",
-        str, "top: %g; ", node->getLayout().position[YGEdgeTop]);
+                         node->getLayout().position[YGEdgeTop]);
-    appendFormatedString(
+    appendFormatedString(str, "left: %g;",
-        str, "left: %g;", node->getLayout().position[YGEdgeLeft]);
+                         node->getLayout().position[YGEdgeLeft]);
     appendFormatedString(str, "\" ");
   }
 
@@ -134,28 +120,24 @@ void YGNodeToString(
     appendFormatedString(str, "style=\"");
     const auto& style = node->getStyle();
     if (style.flexDirection() != YGNode().getStyle().flexDirection()) {
-      appendFormatedString(
+      appendFormatedString(str, "flex-direction: %s; ",
-          str,
-          "flex-direction: %s; ",
                            YGFlexDirectionToString(style.flexDirection()));
     }
     if (style.justifyContent() != YGNode().getStyle().justifyContent()) {
-      appendFormatedString(
+      appendFormatedString(str, "justify-content: %s; ",
-          str,
-          "justify-content: %s; ",
                            YGJustifyToString(style.justifyContent()));
     }
     if (style.alignItems() != YGNode().getStyle().alignItems()) {
-      appendFormatedString(
+      appendFormatedString(str, "align-items: %s; ",
-          str, "align-items: %s; ", YGAlignToString(style.alignItems()));
+                           YGAlignToString(style.alignItems()));
     }
     if (style.alignContent() != YGNode().getStyle().alignContent()) {
-      appendFormatedString(
+      appendFormatedString(str, "align-content: %s; ",
-          str, "align-content: %s; ", YGAlignToString(style.alignContent()));
+                           YGAlignToString(style.alignContent()));
     }
     if (style.alignSelf() != YGNode().getStyle().alignSelf()) {
-      appendFormatedString(
+      appendFormatedString(str, "align-self: %s; ",
-          str, "align-self: %s; ", YGAlignToString(style.alignSelf()));
+                           YGAlignToString(style.alignSelf()));
     }
     appendFloatOptionalIfDefined(str, "flex-grow", style.flexGrow());
     appendFloatOptionalIfDefined(str, "flex-shrink", style.flexShrink());
@@ -163,18 +145,18 @@ void YGNodeToString(
     appendFloatOptionalIfDefined(str, "flex", style.flex());
 
     if (style.flexWrap() != YGNode().getStyle().flexWrap()) {
-      appendFormatedString(
+      appendFormatedString(str, "flex-wrap: %s; ",
-          str, "flex-wrap: %s; ", YGWrapToString(style.flexWrap()));
+                           YGWrapToString(style.flexWrap()));
     }
 
     if (style.overflow() != YGNode().getStyle().overflow()) {
-      appendFormatedString(
+      appendFormatedString(str, "overflow: %s; ",
-          str, "overflow: %s; ", YGOverflowToString(style.overflow()));
+                           YGOverflowToString(style.overflow()));
     }
 
     if (style.display() != YGNode().getStyle().display()) {
-      appendFormatedString(
+      appendFormatedString(str, "display: %s; ",
-          str, "display: %s; ", YGDisplayToString(style.display()));
+                           YGDisplayToString(style.display()));
     }
     appendEdges(str, "margin", style.margin());
     appendEdges(str, "padding", style.padding());
@@ -182,18 +164,18 @@ void YGNodeToString(
 
     appendNumberIfNotAuto(str, "width", style.dimensions()[YGDimensionWidth]);
     appendNumberIfNotAuto(str, "height", style.dimensions()[YGDimensionHeight]);
-    appendNumberIfNotAuto(
+    appendNumberIfNotAuto(str, "max-width",
-        str, "max-width", style.maxDimensions()[YGDimensionWidth]);
+                          style.maxDimensions()[YGDimensionWidth]);
-    appendNumberIfNotAuto(
+    appendNumberIfNotAuto(str, "max-height",
-        str, "max-height", style.maxDimensions()[YGDimensionHeight]);
+                          style.maxDimensions()[YGDimensionHeight]);
-    appendNumberIfNotAuto(
+    appendNumberIfNotAuto(str, "min-width",
-        str, "min-width", style.minDimensions()[YGDimensionWidth]);
+                          style.minDimensions()[YGDimensionWidth]);
-    appendNumberIfNotAuto(
+    appendNumberIfNotAuto(str, "min-height",
-        str, "min-height", style.minDimensions()[YGDimensionHeight]);
+                          style.minDimensions()[YGDimensionHeight]);
 
     if (style.positionType() != YGNode().getStyle().positionType()) {
-      appendFormatedString(
+      appendFormatedString(str, "position: %s; ",
-          str, "position: %s; ", YGPositionTypeToString(style.positionType()));
+                           YGPositionTypeToString(style.positionType()));
     }
 
     appendEdgeIfNotUndefined(str, "left", style.position(), YGEdgeLeft);

src/cpp/include/deps/yoga/YGNodePrint.h

@@ -13,10 +13,7 @@
 namespace facebook {
 namespace yoga {
 
-void YGNodeToString(
+void YGNodeToString(std::string& str, YGNodeRef node, YGPrintOptions options,
-    std::string& str,
-    YGNodeRef node,
-    YGPrintOptions options,
                     uint32_t level);
 
 }  // namespace yoga

src/cpp/include/deps/yoga/YGStyle.cpp

@@ -5,11 +5,13 @@
  * file in the root directory of this source tree.
  */
 #include "YGStyle.h"
+
 #include "Utils.h"
 
 // Yoga specific properties, not compatible with flexbox specification
 bool operator==(const YGStyle& lhs, const YGStyle& rhs) {
-  bool areNonFloatValuesEqual = lhs.direction() == rhs.direction() &&
+  bool areNonFloatValuesEqual =
+      lhs.direction() == rhs.direction() &&
       lhs.flexDirection() == rhs.flexDirection() &&
       lhs.justifyContent() == rhs.justifyContent() &&
       lhs.alignContent() == rhs.alignContent() &&
@@ -32,14 +34,16 @@ bool operator==(const YGStyle& lhs, const YGStyle& rhs) {
     areNonFloatValuesEqual = areNonFloatValuesEqual && lhs.flex() == rhs.flex();
   }
 
-  areNonFloatValuesEqual = areNonFloatValuesEqual &&
+  areNonFloatValuesEqual =
+      areNonFloatValuesEqual &&
       lhs.flexGrow().isUndefined() == rhs.flexGrow().isUndefined();
   if (areNonFloatValuesEqual && !lhs.flexGrow().isUndefined()) {
     areNonFloatValuesEqual =
         areNonFloatValuesEqual && lhs.flexGrow() == rhs.flexGrow();
   }
 
-  areNonFloatValuesEqual = areNonFloatValuesEqual &&
+  areNonFloatValuesEqual =
+      areNonFloatValuesEqual &&
       lhs.flexShrink().isUndefined() == rhs.flexShrink().isUndefined();
   if (areNonFloatValuesEqual && !rhs.flexShrink().isUndefined()) {
     areNonFloatValuesEqual =

src/cpp/include/deps/yoga/YGStyle.h

@@ -9,6 +9,7 @@
 #include <array>
 #include <cstdint>
 #include <type_traits>
+
 #include "Bitfield.h"
 #include "CompactValue.h"
 #include "YGEnums.h"
@@ -73,29 +74,16 @@ private:
   static constexpr size_t flexWrapIdx = 7;
   static constexpr size_t overflowIdx = 8;
   static constexpr size_t displayIdx = 9;
-  using Flags = facebook::yoga::Bitfield<
+  using Flags =
-      uint32_t,
+      facebook::yoga::Bitfield<uint32_t, YGDirection, YGFlexDirection,
-      YGDirection,
+                               YGJustify, YGAlign, YGAlign, YGAlign,
-      YGFlexDirection,
+                               YGPositionType, YGWrap, YGOverflow, YGDisplay>;
-      YGJustify,
-      YGAlign,
-      YGAlign,
-      YGAlign,
-      YGPositionType,
-      YGWrap,
-      YGOverflow,
-      YGDisplay>;
 
-  Flags flags_ = {YGDirectionInherit,
+  Flags flags_ = {YGDirectionInherit,     YGFlexDirectionColumn,
-                  YGFlexDirectionColumn,
+                  YGJustifyFlexStart,     YGAlignFlexStart,
-                  YGJustifyFlexStart,
+                  YGAlignStretch,         YGAlignAuto,
-                  YGAlignFlexStart,
+                  YGPositionTypeRelative, YGWrapNoWrap,
-                  YGAlignStretch,
+                  YGOverflowVisible,      YGDisplayFlex};
-                  YGAlignAuto,
-                  YGPositionTypeRelative,
-                  YGWrapNoWrap,
-                  YGOverflowVisible,
-                  YGDisplayFlex};
   YGFloatOptional flex_ = {};
   YGFloatOptional flexGrow_ = {};
   YGFloatOptional flexShrink_ = {};

src/cpp/include/deps/yoga/YGValue.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <math.h>
+
 #include "YGEnums.h"
 #include "YGMacros.h"
 

src/cpp/include/deps/yoga/Yoga-internal.h

@@ -9,6 +9,7 @@
 #include <array>
 #include <cmath>
 #include <vector>
+
 #include "CompactValue.h"
 #include "Yoga.h"
 
@@ -16,9 +17,7 @@ using YGVector = std::vector<YGNodeRef>;
 
 YG_EXTERN_C_BEGIN
 
-void YGNodeCalculateLayoutWithContext(
+void YGNodeCalculateLayoutWithContext(YGNodeRef node, float availableWidth,
-    YGNodeRef node,
-    float availableWidth,
                                       float availableHeight,
                                       YGDirection ownerDirection,
                                       void* layoutContext);
@@ -28,9 +27,7 @@ YG_EXTERN_C_END
 namespace facebook {
 namespace yoga {
 
-inline bool isUndefined(float value) {
+inline bool isUndefined(float value) { return std::isnan(value); }
-  return std::isnan(value);
-}
 
 }  // namespace yoga
 }  // namespace facebook
@@ -146,5 +143,4 @@ extern bool YGFloatsEqual(const float a, const float b);
 extern facebook::yoga::detail::CompactValue YGComputedEdgeValue(
     const facebook::yoga::detail::Values<
         facebook::yoga::enums::count<YGEdge>()>& edges,
-    YGEdge edge,
+    YGEdge edge, facebook::yoga::detail::CompactValue defaultValue);
-    facebook::yoga::detail::CompactValue defaultValue);

src/cpp/include/deps/yoga/Yoga.h

@@ -33,39 +33,29 @@ typedef struct YGConfig* YGConfigRef;
 typedef struct YGNode* YGNodeRef;
 typedef const struct YGNode* YGNodeConstRef;
 
-typedef YGSize (*YGMeasureFunc)(
+typedef YGSize (*YGMeasureFunc)(YGNodeRef node, float width,
-    YGNodeRef node,
+                                YGMeasureMode widthMode, float height,
-    float width,
-    YGMeasureMode widthMode,
-    float height,
                                 YGMeasureMode heightMode);
 typedef float (*YGBaselineFunc)(YGNodeRef node, float width, float height);
 typedef void (*YGDirtiedFunc)(YGNodeRef node);
 typedef void (*YGPrintFunc)(YGNodeRef node);
 typedef void (*YGNodeCleanupFunc)(YGNodeRef node);
-typedef int (*YGLogger)(
+typedef int (*YGLogger)(YGConfigRef config, YGNodeRef node, YGLogLevel level,
-    YGConfigRef config,
+                        const char* format, va_list args);
-    YGNodeRef node,
+typedef YGNodeRef (*YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner,
-    YGLogLevel level,
+                                     int childIndex);
-    const char* format,
-    va_list args);
-typedef YGNodeRef (
-    *YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner, int childIndex);
 
 // YGNode
 WIN_EXPORT YGNodeRef YGNodeNew(void);
 WIN_EXPORT YGNodeRef YGNodeNewWithConfig(YGConfigRef config);
 WIN_EXPORT YGNodeRef YGNodeClone(YGNodeRef node);
 WIN_EXPORT void YGNodeFree(YGNodeRef node);
-WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(
+WIN_EXPORT void YGNodeFreeRecursiveWithCleanupFunc(YGNodeRef node,
-    YGNodeRef node,
                                                    YGNodeCleanupFunc cleanup);
 WIN_EXPORT void YGNodeFreeRecursive(YGNodeRef node);
 WIN_EXPORT void YGNodeReset(YGNodeRef node);
 
-WIN_EXPORT void YGNodeInsertChild(
+WIN_EXPORT void YGNodeInsertChild(YGNodeRef node, YGNodeRef child,
-    YGNodeRef node,
-    YGNodeRef child,
                                   uint32_t index);
 
 WIN_EXPORT void YGNodeRemoveChild(YGNodeRef node, YGNodeRef child);
@@ -74,20 +64,15 @@ WIN_EXPORT YGNodeRef YGNodeGetChild(YGNodeRef node, uint32_t index);
 WIN_EXPORT YGNodeRef YGNodeGetOwner(YGNodeRef node);
 WIN_EXPORT YGNodeRef YGNodeGetParent(YGNodeRef node);
 WIN_EXPORT uint32_t YGNodeGetChildCount(YGNodeRef node);
-WIN_EXPORT void YGNodeSetChildren(
+WIN_EXPORT void YGNodeSetChildren(YGNodeRef owner, const YGNodeRef children[],
-    YGNodeRef owner,
-    const YGNodeRef children[],
                                   uint32_t count);
 
-WIN_EXPORT void YGNodeSetIsReferenceBaseline(
+WIN_EXPORT void YGNodeSetIsReferenceBaseline(YGNodeRef node,
-    YGNodeRef node,
                                              bool isReferenceBaseline);
 
 WIN_EXPORT bool YGNodeIsReferenceBaseline(YGNodeRef node);
 
-WIN_EXPORT void YGNodeCalculateLayout(
+WIN_EXPORT void YGNodeCalculateLayout(YGNodeRef node, float availableWidth,
-    YGNodeRef node,
-    float availableWidth,
                                       float availableHeight,
                                       YGDirection ownerDirection);
 
@@ -110,18 +95,10 @@ WIN_EXPORT void YGNodePrint(YGNodeRef node, YGPrintOptions options);
 WIN_EXPORT bool YGFloatIsUndefined(float value);
 
 WIN_EXPORT bool YGNodeCanUseCachedMeasurement(
-    YGMeasureMode widthMode,
+    YGMeasureMode widthMode, float width, YGMeasureMode heightMode,
-    float width,
+    float height, YGMeasureMode lastWidthMode, float lastWidth,
-    YGMeasureMode heightMode,
+    YGMeasureMode lastHeightMode, float lastHeight, float lastComputedWidth,
-    float height,
+    float lastComputedHeight, float marginRow, float marginColumn,
-    YGMeasureMode lastWidthMode,
-    float lastWidth,
-    YGMeasureMode lastHeightMode,
-    float lastHeight,
-    float lastComputedWidth,
-    float lastComputedHeight,
-    float marginRow,
-    float marginColumn,
     YGConfigRef config);
 
 WIN_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeRef srcNode);
@@ -146,18 +123,15 @@ bool YGNodeLayoutGetDidUseLegacyFlag(YGNodeRef node);
 WIN_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction);
 WIN_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeConstRef node);
 
-WIN_EXPORT void YGNodeStyleSetFlexDirection(
+WIN_EXPORT void YGNodeStyleSetFlexDirection(YGNodeRef node,
-    YGNodeRef node,
                                             YGFlexDirection flexDirection);
 WIN_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeConstRef node);
 
-WIN_EXPORT void YGNodeStyleSetJustifyContent(
+WIN_EXPORT void YGNodeStyleSetJustifyContent(YGNodeRef node,
-    YGNodeRef node,
                                              YGJustify justifyContent);
 WIN_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node);
 
-WIN_EXPORT void YGNodeStyleSetAlignContent(
+WIN_EXPORT void YGNodeStyleSetAlignContent(YGNodeRef node,
-    YGNodeRef node,
                                            YGAlign alignContent);
 WIN_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node);
 
@@ -167,8 +141,7 @@ WIN_EXPORT YGAlign YGNodeStyleGetAlignItems(YGNodeConstRef node);
 WIN_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf);
 WIN_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeConstRef node);
 
-WIN_EXPORT void YGNodeStyleSetPositionType(
+WIN_EXPORT void YGNodeStyleSetPositionType(YGNodeRef node,
-    YGNodeRef node,
                                            YGPositionType positionType);
 WIN_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeConstRef node);
 
@@ -195,31 +168,21 @@ WIN_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
 WIN_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
 WIN_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);
 
-WIN_EXPORT void YGNodeStyleSetPosition(
+WIN_EXPORT void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge,
-    YGNodeRef node,
-    YGEdge edge,
                                        float position);
-WIN_EXPORT void YGNodeStyleSetPositionPercent(
+WIN_EXPORT void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge,
-    YGNodeRef node,
-    YGEdge edge,
                                               float position);
 WIN_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge);
 
 WIN_EXPORT void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
-WIN_EXPORT void YGNodeStyleSetMarginPercent(
+WIN_EXPORT void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge,
-    YGNodeRef node,
-    YGEdge edge,
                                             float margin);
 WIN_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);
 WIN_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge);
 
-WIN_EXPORT void YGNodeStyleSetPadding(
+WIN_EXPORT void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge,
-    YGNodeRef node,
-    YGEdge edge,
                                       float padding);
-WIN_EXPORT void YGNodeStyleSetPaddingPercent(
+WIN_EXPORT void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge,
-    YGNodeRef node,
-    YGEdge edge,
                                              float padding);
 WIN_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge);
 
@@ -290,22 +253,16 @@ WIN_EXPORT float YGNodeLayoutGetPadding(YGNodeRef node, YGEdge edge);
 
 WIN_EXPORT void YGConfigSetLogger(YGConfigRef config, YGLogger logger);
 WIN_EXPORT void YGAssert(bool condition, const char* message);
-WIN_EXPORT void YGAssertWithNode(
+WIN_EXPORT void YGAssertWithNode(YGNodeRef node, bool condition,
-    YGNodeRef node,
-    bool condition,
                                  const char* message);
-WIN_EXPORT void YGAssertWithConfig(
+WIN_EXPORT void YGAssertWithConfig(YGConfigRef config, bool condition,
-    YGConfigRef config,
-    bool condition,
                                    const char* message);
 // Set this to number of pixels in 1 point to round calculation results If you
 // want to avoid rounding - set PointScaleFactor to 0
-WIN_EXPORT void YGConfigSetPointScaleFactor(
+WIN_EXPORT void YGConfigSetPointScaleFactor(YGConfigRef config,
-    YGConfigRef config,
                                             float pixelsInPoint);
 void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
-    YGConfigRef config,
+    YGConfigRef config, bool shouldDiffLayout);
-    bool shouldDiffLayout);
 
 // Yoga previously had an error where containers would take the maximum space
 // possible instead of the minimum like they are supposed to. In practice this
@@ -313,8 +270,7 @@ void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
 // was such a long-standing bug we must allow legacy users to switch back to
 // this behaviour.
 WIN_EXPORT void YGConfigSetUseLegacyStretchBehaviour(
-    YGConfigRef config,
+    YGConfigRef config, bool useLegacyStretchBehaviour);
-    bool useLegacyStretchBehaviour);
 
 // YGConfig
 WIN_EXPORT YGConfigRef YGConfigNew(void);
@@ -323,20 +279,16 @@ WIN_EXPORT void YGConfigCopy(YGConfigRef dest, YGConfigRef src);
 WIN_EXPORT int32_t YGConfigGetInstanceCount(void);
 
 WIN_EXPORT void YGConfigSetExperimentalFeatureEnabled(
-    YGConfigRef config,
+    YGConfigRef config, YGExperimentalFeature feature, bool enabled);
-    YGExperimentalFeature feature,
-    bool enabled);
 WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(
-    YGConfigRef config,
+    YGConfigRef config, YGExperimentalFeature feature);
-    YGExperimentalFeature feature);
 
 // Using the web defaults is the preferred configuration for new projects. Usage
 // of non web defaults should be considered as legacy.
 WIN_EXPORT void YGConfigSetUseWebDefaults(YGConfigRef config, bool enabled);
 WIN_EXPORT bool YGConfigGetUseWebDefaults(YGConfigRef config);
 
-WIN_EXPORT void YGConfigSetCloneNodeFunc(
+WIN_EXPORT void YGConfigSetCloneNodeFunc(YGConfigRef config,
-    YGConfigRef config,
                                          YGCloneNodeFunc callback);
 
 // Export only for C#
@@ -345,11 +297,8 @@ WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
 WIN_EXPORT void YGConfigSetContext(YGConfigRef config, void* context);
 WIN_EXPORT void* YGConfigGetContext(YGConfigRef config);
 
-WIN_EXPORT float YGRoundValueToPixelGrid(
+WIN_EXPORT float YGRoundValueToPixelGrid(float value, float pointScaleFactor,
-    float value,
+                                         bool forceCeil, bool forceFloor);
-    float pointScaleFactor,
-    bool forceCeil,
-    bool forceFloor);
 
 YG_EXTERN_C_END
 
@@ -359,8 +308,7 @@ YG_EXTERN_C_END
 #include <vector>
 
 // Calls f on each node in the tree including the given node argument.
-void YGTraversePreOrder(
+void YGTraversePreOrder(YGNodeRef node,
-    YGNodeRef node,
                         std::function<void(YGNodeRef node)>&& f);
 
 void YGNodeSetChildren(YGNodeRef owner, const std::vector<YGNodeRef>& children);

src/cpp/include/deps/yoga/event/event.cpp

@@ -5,6 +5,7 @@
  * file in the root directory of this source tree.
  */
 #include "event.h"
+
 #include <atomic>
 #include <memory>
 #include <stdexcept>
@@ -76,8 +77,7 @@ void Event::subscribe(std::function<Subscriber>&& subscriber) {
 
 void Event::publish(const YGNode& node, Type eventType, const Data& eventData) {
   for (auto subscriber = subscribers.load(std::memory_order_relaxed);
-       subscriber != nullptr;
+       subscriber != nullptr; subscriber = subscriber->next) {
-       subscriber = subscriber->next) {
     subscriber->subscriber(node, eventType, eventData);
   }
 }

src/cpp/include/deps/yoga/event/event.h

@@ -6,10 +6,11 @@
  */
 #pragma once
 
+#include <yoga/YGEnums.h>
+
+#include <array>
 #include <functional>
 #include <vector>
-#include <array>
-#include <yoga/YGEnums.h>
 
 struct YGConfig;
 struct YGNode;

src/cpp/include/deps/yoga/internal/experiments-inl.h

@@ -6,10 +6,10 @@
  */
 #pragma once
 
-#include "experiments.h"
-
 #include <bitset>
 
+#include "experiments.h"
+
 namespace facebook {
 namespace yoga {
 namespace internal {
@@ -22,9 +22,7 @@ inline bool isEnabled(Experiment experiment) {
   return detail::enabledExperiments.test(static_cast<size_t>(experiment));
 }
 
-inline void disableAllExperiments() {
+inline void disableAllExperiments() { detail::enabledExperiments = 0; }
-  detail::enabledExperiments = 0;
-}
 
 }  // namespace internal
 }  // namespace yoga

src/cpp/include/deps/yoga/internal/experiments.cpp

@@ -5,6 +5,7 @@
  * file in the root directory of this source tree.
  */
 #include "experiments.h"
+
 #include "experiments-inl.h"
 
 namespace facebook {

src/cpp/include/deps/yoga/log.cpp

@@ -6,9 +6,9 @@
  */
 #include "log.h"
 
-#include "Yoga.h"
 #include "YGConfig.h"
 #include "YGNode.h"
+#include "Yoga.h"
 
 namespace facebook {
 namespace yoga {
@@ -16,13 +16,8 @@ namespace detail {
 
 namespace {
 
-void vlog(
+void vlog(YGConfig* config, YGNode* node, YGLogLevel level, void* context,
-    YGConfig* config,
+          const char* format, va_list args) {
-    YGNode* node,
-    YGLogLevel level,
-    void* context,
-    const char* format,
-    va_list args) {
   YGConfig* logConfig = config != nullptr ? config : YGConfigGetDefault();
   logConfig->log(logConfig, node, level, context, format, args);
 
@@ -32,30 +27,17 @@ void vlog(
 }
 }  // namespace
 
-void Log::log(
+void Log::log(YGNode* node, YGLogLevel level, void* context, const char* format,
-    YGNode* node,
-    YGLogLevel level,
-    void* context,
-    const char* format,
               ...) noexcept {
   va_list args;
   va_start(args, format);
-  vlog(
+  vlog(node == nullptr ? nullptr : node->getConfig(), node, level, context,
-      node == nullptr ? nullptr : node->getConfig(),
+       format, args);
-      node,
-      level,
-      context,
-      format,
-      args);
   va_end(args);
 }
 
-void Log::log(
+void Log::log(YGConfig* config, YGLogLevel level, void* context,
-    YGConfig* config,
+              const char* format, ...) noexcept {
-    YGLogLevel level,
-    void* context,
-    const char* format,
-    ...) noexcept {
   va_list args;
   va_start(args, format);
   vlog(config, nullptr, level, context, format, args);

src/cpp/include/deps/yoga/log.h

@@ -17,18 +17,10 @@ namespace yoga {
 namespace detail {
 
 struct Log {
-  static void log(
+  static void log(YGNode* node, YGLogLevel level, void*, const char* message,
-      YGNode* node,
-      YGLogLevel level,
-      void*,
-      const char* message,
                   ...) noexcept;
 
-  static void log(
+  static void log(YGConfig* config, YGLogLevel level, void*, const char* format,
-      YGConfig* config,
-      YGLogLevel level,
-      void*,
-      const char* format,
                   ...) noexcept;
 };
 

src/cpp/include/nodegui/Extras/Utils/nutils.h

@@ -3,6 +3,6 @@
 #include "core/FlexLayout/flexlayout.h"
 
 namespace extrautils {
-     YGSize measureQtWidget (YGNodeRef node, float width, YGMeasureMode widthMode, float height, YGMeasureMode heightMode);
+YGSize measureQtWidget(YGNodeRef node, float width, YGMeasureMode widthMode,
+                       float height, YGMeasureMode heightMode);
 }
-

src/cpp/include/nodegui/QtCore/QObject/qobject_macro.h

@@ -1,11 +1,12 @@
 #pragma once
 
-#include "core/Events/eventwidget_macro.h"
 #include "core/Component/component_macro.h"
+#include "core/Events/eventwidget_macro.h"
 /*
 
     This macro adds common QObject exported methods
-    The exported methods are taken into this macro to avoid writing them in each and every widget we export.
+    The exported methods are taken into this macro to avoid writing them in each
+   and every widget we export.
  */
 
 #ifndef QOBJECT_WRAPPED_METHODS_DECLARATION
@@ -19,8 +20,7 @@ Napi::Value inherits(const Napi::CallbackInfo& info){ \
     Napi::String className = info[0].As<Napi::String>();                   \
     bool doesIt = this->instance->inherits(className.Utf8Value().c_str()); \
     return Napi::Value::From(env, doesIt);                                 \
-} \
+  }
-\
 
 #endif  // QOBJECT_WRAPPED_METHODS_DECLARATION
 
@@ -30,7 +30,6 @@ Napi::Value inherits(const Napi::CallbackInfo& info){ \
   EVENTWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName)   \
   COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE                        \
                                                                  \
- InstanceMethod("inherits", &ComponentWrapName::inherits),\
+  InstanceMethod("inherits", &ComponentWrapName::inherits),
- \
 
 #endif  // QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE

src/cpp/include/nodegui/QtGui/QApplication/qapplication_wrap.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <napi.h>
-#include <QApplication>
 
+#include <QApplication>
 
 class QApplicationWrap : public Napi::ObjectWrap<QApplicationWrap> {
  private:
@@ -29,4 +29,4 @@ public:
 namespace StaticQApplicationWrapMethods {
 Napi::Value instance(const Napi::CallbackInfo& info);
 Napi::Value clipboard(const Napi::CallbackInfo& info);
-}
+}  // namespace StaticQApplicationWrapMethods

src/cpp/include/nodegui/QtGui/QClipboard/qclipboard_wrap.h

@@ -1,13 +1,15 @@
 #pragma once
 
 #include <napi.h>
+
 #include <QClipboard>
+
 #include "core/Component/component_macro.h"
 
-class QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap>
+class QClipboardWrap : public Napi::ObjectWrap<QClipboardWrap> {
-{
  private:
   QClipboard* instance;
+
  public:
   static Napi::FunctionReference constructor;
   static Napi::Object init(Napi::Env env, Napi::Object exports);

src/cpp/include/nodegui/QtGui/QCursor/qcursor_wrap.h

@@ -2,13 +2,15 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QCursor>
+
 #include "core/Component/component_macro.h"
 
-class QCursorWrap : public Napi::ObjectWrap<QCursorWrap>
+class QCursorWrap : public Napi::ObjectWrap<QCursorWrap> {
-{
  private:
   std::unique_ptr<QCursor> instance;
+
  public:
   static Napi::FunctionReference constructor;
   static Napi::Object init(Napi::Env env, Napi::Object exports);

src/cpp/include/nodegui/QtGui/QEvent/QKeyEvent/qkeyevent_wrap.h

@@ -2,6 +2,7 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QKeyEvent>
 
 class QKeyEventWrap : public Napi::ObjectWrap<QKeyEventWrap> {

src/cpp/include/nodegui/QtGui/QIcon/qicon_wrap.h

@@ -2,11 +2,12 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QIcon>
+
 #include "core/Component/component_macro.h"
 
-class QIconWrap : public Napi::ObjectWrap<QIconWrap>
+class QIconWrap : public Napi::ObjectWrap<QIconWrap> {
-{
  private:
   std::unique_ptr<QIcon> instance;
 

src/cpp/include/nodegui/QtGui/QKeySequence/qkeysequence_wrap.h

@@ -2,11 +2,12 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QKeySequence>
+
 #include "core/Component/component_macro.h"
 
-class QKeySequenceWrap : public Napi::ObjectWrap<QKeySequenceWrap>
+class QKeySequenceWrap : public Napi::ObjectWrap<QKeySequenceWrap> {
-{
  private:
   std::unique_ptr<QKeySequence> instance;
 

src/cpp/include/nodegui/QtGui/QPixmap/qpixmap_wrap.h

@@ -2,12 +2,15 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QPixmap>
+
 #include "core/Component/component_macro.h"
 
 class QPixmapWrap : public Napi::ObjectWrap<QPixmapWrap> {
  private:
   std::unique_ptr<QPixmap> instance;
+
  public:
   static Napi::FunctionReference constructor;
   static Napi::Object init(Napi::Env env, Napi::Object exports);
@@ -19,4 +22,3 @@ public:
   Napi::Value save(const Napi::CallbackInfo& info);
   Napi::Value scaled(const Napi::CallbackInfo& info);
 };
-

src/cpp/include/nodegui/QtWidgets/QAbstractScrollArea/qabstractscrollarea_macro.h

@@ -1,12 +1,13 @@
 
 #pragma once
-#include "QtWidgets/QWidget/qwidget_wrap.h"
 #include "QtWidgets/QWidget/qwidget_macro.h"
+#include "QtWidgets/QWidget/qwidget_wrap.h"
 #include "deps/spdlog/spdlog.h"
 /*
 
     This macro adds common QAbstractScrollArea exported methods
-    The exported methods are taken into this macro to avoid writing them in each and every widget we export.
+    The exported methods are taken into this macro to avoid writing them in each
+   and every widget we export.
  */
 
 #ifndef QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
@@ -16,7 +17,8 @@ Napi::Value setViewport(const Napi::CallbackInfo& info) { \
     Napi::Env env = info.Env();                                    \
     Napi::HandleScope scope(env);                                  \
     Napi::Object viewPortObject = info[0].As<Napi::Object>();      \
-    QWidgetWrap* viewPortWidgetWrap = Napi::ObjectWrap<QWidgetWrap>::Unwrap(viewPortObject); \
+    QWidgetWrap* viewPortWidgetWrap =                              \
+        Napi::ObjectWrap<QWidgetWrap>::Unwrap(viewPortObject);     \
     QWidget* viewPort = viewPortWidgetWrap->getInternalInstance(); \
     this->instance->setViewport(viewPort);                         \
     return env.Null();                                             \
@@ -27,10 +29,10 @@ Napi::Value viewport(const Napi::CallbackInfo& info) { \
     Napi::HandleScope scope(env);                                  \
     QWidget* viewPort = this->instance->viewport();                \
     NWidget* nviewPort = reinterpret_cast<NWidget*>(viewPort);     \
-    auto instance = QWidgetWrap::constructor.New({ Napi::External<NWidget>::New(env, nviewPort) }); \
+    auto instance = QWidgetWrap::constructor.New(                  \
+        {Napi::External<NWidget>::New(env, nviewPort)});           \
     return instance;                                               \
-} \
+  }
-\
 
 #endif  // QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
 
@@ -38,6 +40,6 @@ Napi::Value viewport(const Napi::CallbackInfo& info) { \
 #define QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \
   QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName)                   \
   InstanceMethod("setViewport", &WidgetWrapName::setViewport),            \
- InstanceMethod("viewport",&WidgetWrapName::viewport), \
+      InstanceMethod("viewport", &WidgetWrapName::viewport),
 
 #endif  // QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE

src/cpp/include/nodegui/QtWidgets/QAbstractSlider/qabstractslider_macro.h

@@ -1,12 +1,13 @@
 
 #pragma once
-#include "QtWidgets/QWidget/qwidget_wrap.h"
 #include "QtWidgets/QWidget/qwidget_macro.h"
+#include "QtWidgets/QWidget/qwidget_wrap.h"
 #include "deps/spdlog/spdlog.h"
 /*
 
     This macro adds common QAbstractSlider exported methods
-    The exported methods are taken into this macro to avoid writing them in each and every widget we export.
+    The exported methods are taken into this macro to avoid writing them in each
+   and every widget we export.
  */
 
 #ifndef QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
@@ -48,7 +49,8 @@ Napi::Value setOrientation(const Napi::CallbackInfo& info) { \
     Napi::Env env = info.Env();                                  \
     Napi::HandleScope scope(env);                                \
     Napi::Number orientation = info[0].As<Napi::Number>();       \
-    this->instance->setOrientation(static_cast<Qt::Orientation>(orientation.Int32Value())); \
+    this->instance->setOrientation(                              \
+        static_cast<Qt::Orientation>(orientation.Int32Value())); \
     return env.Null();                                           \
   }                                                              \
                                                                  \
@@ -71,8 +73,7 @@ Napi::Value value(const Napi::CallbackInfo& info) { \
     Napi::HandleScope scope(env);                                \
     int value = this->instance->value();                         \
     return Napi::Number::New(env, value);                        \
-} \
+  }
-\
 
 #endif  // QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
 
@@ -86,6 +87,6 @@ Napi::Value value(const Napi::CallbackInfo& info) { \
       InstanceMethod("setOrientation", &WidgetWrapName::setOrientation), \
       InstanceMethod("maximum", &WidgetWrapName::maximum),               \
       InstanceMethod("minimum", &WidgetWrapName::minimum),               \
- InstanceMethod("value", &WidgetWrapName::value),  \
+      InstanceMethod("value", &WidgetWrapName::value),
 
 #endif  // QABSTRACTSLIDER_WRAPPED_METHODS_EXPORT_DEFINE

src/cpp/include/nodegui/QtWidgets/QAction/naction.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <QAction>
+
 #include "core/NodeWidget/nodewidget.h"
 #include "napi.h"
 
-class NAction: public QAction, public EventWidget
+class NAction : public QAction, public EventWidget {
-{
   Q_OBJECT
   EVENTWIDGET_IMPLEMENTATIONS(QAction)
  public:
@@ -15,7 +15,8 @@ public:
     QObject::connect(this, &QAction::triggered, [=](bool checked) {
       Napi::Env env = this->emitOnNode.Env();
       Napi::HandleScope scope(env);
-            this->emitOnNode.Call({  Napi::String::New(env, "triggered"), Napi::Value::From(env, checked) });
+      this->emitOnNode.Call({Napi::String::New(env, "triggered"),
+                             Napi::Value::From(env, checked)});
     });
     QObject::connect(this, &QAction::changed, [=]() {
       Napi::Env env = this->emitOnNode.Env();
@@ -30,9 +31,8 @@ public:
     QObject::connect(this, &QAction::toggled, [=](bool checked) {
       Napi::Env env = this->emitOnNode.Env();
       Napi::HandleScope scope(env);
-            this->emitOnNode.Call({  Napi::String::New(env, "toggled"), Napi::Value::From(env, checked) });
+      this->emitOnNode.Call(
+          {Napi::String::New(env, "toggled"), Napi::Value::From(env, checked)});
     });
   }
 };
-
-

src/cpp/include/nodegui/QtWidgets/QAction/qaction_wrap.h

@@ -1,12 +1,14 @@
 #pragma once
 
 #include <napi.h>
-#include "naction.hpp"
+
 #include "QtWidgets/QWidget/qwidget_macro.h"
+#include "naction.hpp"
 
 class QActionWrap : public Napi::ObjectWrap<QActionWrap> {
  private:
   NAction* instance;
+
  public:
   static Napi::Object init(Napi::Env env, Napi::Object exports);
   QActionWrap(const Napi::CallbackInfo& info);
@@ -30,4 +32,3 @@ class QActionWrap : public  Napi::ObjectWrap<QActionWrap>{
 
   EVENTWIDGET_WRAPPED_METHODS_DECLARATION
 };
-

src/cpp/include/nodegui/QtWidgets/QCheckBox/ncheckbox.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <QCheckBox>
+
 #include "core/NodeWidget/nodewidget.h"
 #include "napi.h"
 
-class NCheckBox: public QCheckBox, public NodeWidget
+class NCheckBox : public QCheckBox, public NodeWidget {
-{
   Q_OBJECT
   NODEWIDGET_IMPLEMENTATIONS(QCheckBox)
  public:
@@ -15,9 +15,8 @@ public:
     QObject::connect(this, &QCheckBox::toggled, [=](bool checked) {
       Napi::Env env = this->emitOnNode.Env();
       Napi::HandleScope scope(env);
-            this->emitOnNode.Call({  Napi::String::New(env, "toggled"), Napi::Value::From(env, checked) });
+      this->emitOnNode.Call(
+          {Napi::String::New(env, "toggled"), Napi::Value::From(env, checked)});
     });
   }
 };
-
-

src/cpp/include/nodegui/QtWidgets/QCheckBox/qcheckbox_wrap.h

@@ -2,13 +2,14 @@
 
 #include <napi.h>
 #include <stdlib.h>
-#include "ncheckbox.hpp"
-#include "QtWidgets/QWidget/qwidget_macro.h"
 
+#include "QtWidgets/QWidget/qwidget_macro.h"
+#include "ncheckbox.hpp"
 
 class QCheckBoxWrap : public Napi::ObjectWrap<QCheckBoxWrap> {
  private:
   std::unique_ptr<NCheckBox> instance;
+
  public:
   static Napi::Object init(Napi::Env env, Napi::Object exports);
   QCheckBoxWrap(const Napi::CallbackInfo& info);
@@ -23,4 +24,3 @@ class QCheckBoxWrap : public  Napi::ObjectWrap<QCheckBoxWrap>{
 
   QWIDGET_WRAPPED_METHODS_DECLARATION
 };
-

src/cpp/include/nodegui/QtWidgets/QDial/ndial.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
 #include <QDial>
+
 #include "core/NodeWidget/nodewidget.h"
 
-class NDial: public QDial, public NodeWidget
+class NDial : public QDial, public NodeWidget {
-{
   Q_OBJECT
   NODEWIDGET_IMPLEMENTATIONS(QDial)
  public:
@@ -39,5 +39,3 @@ public:
     });
   }
 };
-
-

src/cpp/include/nodegui/QtWidgets/QDial/qdial_wrap.h

@@ -2,14 +2,15 @@
 
 #include <napi.h>
 #include <stdlib.h>
-#include <stdlib.h>
+
-#include "ndial.hpp"
-#include "QtWidgets/QWidget/qwidget_macro.h"
 #include "QtWidgets/QAbstractSlider/qabstractslider_macro.h"
+#include "QtWidgets/QWidget/qwidget_macro.h"
+#include "ndial.hpp"
 
 class QDialWrap : public Napi::ObjectWrap<QDialWrap> {
  private:
   std::unique_ptr<NDial> instance;
+
  public:
   static Napi::Object init(Napi::Env env, Napi::Object exports);
   QDialWrap(const Napi::CallbackInfo& info);
@@ -27,5 +28,3 @@ class QDialWrap : public  Napi::ObjectWrap<QDialWrap>{
 
   QABSTRACTSLIDER_WRAPPED_METHODS_DECLARATION
 };
-
-

src/cpp/include/nodegui/QtWidgets/QGridLayout/qgridlayout_wrap.h

@@ -2,7 +2,9 @@
 
 #include <napi.h>
 #include <stdlib.h>
+
 #include <QGridLayout>
+
 #include "QtWidgets/QLayout/qlayout_macro.h"
 
 class QGridLayoutWrap : public Napi::ObjectWrap<QGridLayoutWrap> {
@@ -21,4 +23,3 @@ class QGridLayoutWrap : public  Napi::ObjectWrap<QGridLayoutWrap>{
   Napi::Value removeWidget(const Napi::CallbackInfo& info);
   QLAYOUT_WRAPPED_METHODS_DECLARATION
 };
-

src/cpp/include/nodegui/QtWidgets/QLabel/nlabel.hpp

@@ -1,14 +1,12 @@
 #pragma once
 
 #include <QLabel>
+
 #include "core/NodeWidget/nodewidget.h"
 
-class NLabel: public QLabel, public NodeWidget
+class NLabel : public QLabel, public NodeWidget {
-{
   Q_OBJECT
   NODEWIDGET_IMPLEMENTATIONS(QLabel)
  public:
   using QLabel::QLabel;  // inherit all constructors of QLabel
 };
-
-