code format

bench/async_bench.cpp

@@ -6,14 +6,14 @@
 //
 // bench.cpp : spdlog benchmarks
 //
+#include <algorithm>
 #include <atomic>
-#include <iostream>
 #include <fstream>
+#include <iostream>
+#include <locale>
 #include <memory>
 #include <string>
 #include <thread>
-#include <locale>
-#include <algorithm>
 
 #include "spdlog/sinks/async_sink.h"
 #include "spdlog/sinks/basic_file_sink.h"

bench/latency.cpp

@@ -124,7 +124,8 @@ int main(int argc, char *argv[]) {
         benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
 
         // rotating st
-        auto rotating_st = spdlog::create<rotating_file_sink_st>("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
+        auto rotating_st =
+            spdlog::create<rotating_file_sink_st>("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
         benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
 
         // daily st
@@ -142,7 +143,8 @@ int main(int argc, char *argv[]) {
         benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
 
         // rotating mt
-        auto rotating_mt = spdlog::create<rotating_file_sink_mt>("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
+        auto rotating_mt =
+            spdlog::create<rotating_file_sink_mt>("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
         benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
 
         // daily mt
@@ -151,7 +153,8 @@ int main(int argc, char *argv[]) {
     }
     using spdlog::sinks::async_sink;
     async_sink::config config;
-    config.queue_size = 3 * 1024 * 1024;;
+    config.queue_size = 3 * 1024 * 1024;
+    ;
     config.sinks.push_back(std::make_shared<null_sink_st>());
     config.policy = async_sink::overflow_policy::overrun_oldest;
     auto async_logger = std::make_shared<spdlog::logger>("async_logger", std::make_shared<async_sink>(config));

include/spdlog/common.h

@@ -6,13 +6,13 @@
 #include <array>
 #include <atomic>
 #include <chrono>
+#include <cstdint>
 #include <exception>
 #include <functional>
 #include <initializer_list>
 #include <memory>
 #include <string>
 #include <string_view>
-#include <cstdint>
 
 #include "./source_loc.h"
 #include "fmt/base.h"

include/spdlog/details/async_log_msg.h

@@ -4,29 +4,27 @@
 #pragma once
 
 #include <cstdint>
+
 #include "./log_msg.h"
 
 namespace spdlog {
 namespace details {
 
-
 // Extend log_msg with internal buffer to store its payload.
 // This is needed since log_msg holds string_views that points to stack data.
-
 class SPDLOG_API async_log_msg : public log_msg {
 public:
     enum class type : std::uint8_t { log, flush, terminate };
     async_log_msg() = default;
     explicit async_log_msg(type type);
     async_log_msg(type type, const log_msg &orig_msg);
-
     ~async_log_msg() = default;
     async_log_msg(const async_log_msg &other);
     async_log_msg(async_log_msg &&other) noexcept;
     async_log_msg &operator=(const async_log_msg &other);
     async_log_msg &operator=(async_log_msg &&other) noexcept;
+    [[nodiscard]] type message_type() const { return msg_type_; }
 
-    type message_type() const {return msg_type_;}
 private:
     type msg_type_{type::log};
     memory_buf_t buffer_;

include/spdlog/details/err_helper.h

@@ -3,10 +3,11 @@
 
 #pragma once
 
-#include <string>
 #include <chrono>
 #include <exception>
 #include <mutex>
+#include <string>
+
 #include "spdlog/common.h"
 
 // by default, prints the error to stderr, at max rate of 1/sec thread safe
@@ -16,6 +17,7 @@ class SPDLOG_API err_helper {
     err_handler custom_err_handler_;
     std::chrono::steady_clock::time_point last_report_time_;
     mutable std::mutex mutex_;
+
 public:
     err_helper() = default;
     ~err_helper() = default;

include/spdlog/sinks/async_sink.h

@@ -91,7 +91,6 @@ public:
         return std::make_shared<async_sink>(cfg);
     }
 
-
 private:
     using async_log_msg = details::async_log_msg;
     using queue_t = details::mpmc_blocking_queue<async_log_msg>;

include/spdlog/sinks/mongo_sink.h

@@ -16,11 +16,11 @@
 #include <mongocxx/client.hpp>
 #include <mongocxx/instance.hpp>
 #include <mongocxx/uri.hpp>
-
 #include <mutex>
-#include "../details/null_mutex.h"
+
 #include "../common.h"
 #include "../details/log_msg.h"
+#include "../details/null_mutex.h"
 #include "./base_sink.h"
 
 namespace spdlog {

include/spdlog/sinks/msvc_sink.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <mutex>
+
 #include "../details/null_mutex.h"
 #include "./base_sink.h"
 

include/spdlog/sinks/ringbuffer_sink.h

@@ -46,7 +46,9 @@ public:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override { q_.push_back(details::async_log_msg{details::async_log_msg::type::log, msg}); }
+    void sink_it_(const details::log_msg &msg) override {
+        q_.push_back(details::async_log_msg{details::async_log_msg::type::log, msg});
+    }
     void flush_() override {}
 
 private:

include/spdlog/sinks/syslog_sink.h

@@ -8,8 +8,8 @@
 #include <syslog.h>
 
 #include <array>
-#include <string>
 #include <mutex>
+#include <string>
 
 namespace spdlog {
 namespace sinks {

src/details/async_log_msg.cpp

@@ -6,7 +6,6 @@
 namespace spdlog {
 namespace details {
 
-
 async_log_msg::async_log_msg(const type type)
     : msg_type_{type} {}
 
@@ -15,21 +14,25 @@ async_log_msg::async_log_msg(const type type)
 // are compiler generated const chars* (__FILE__, __LINE__, __FUNCTION__)
 // if you pass custom strings to source location, make sure they outlive the async_log_msg
 async_log_msg::async_log_msg(const type type, const log_msg &orig_msg)
-    : log_msg{orig_msg}, msg_type_(type) {
+    : log_msg{orig_msg},
+      msg_type_(type) {
     buffer_.append(logger_name);
     buffer_.append(payload);
     update_string_views();
 }
 
 async_log_msg::async_log_msg(const async_log_msg &other)
-    : log_msg{other}, msg_type_{other.msg_type_} {
+    : log_msg{other},
+      msg_type_{other.msg_type_} {
     buffer_.append(logger_name);
     buffer_.append(payload);
     update_string_views();
 }
 
 async_log_msg::async_log_msg(async_log_msg &&other) noexcept
-    : log_msg{other}, msg_type_{other.msg_type_}, buffer_{std::move(other.buffer_)} {
+    : log_msg{other},
+      msg_type_{other.msg_type_},
+      buffer_{std::move(other.buffer_)} {
     update_string_views();
 }
 

src/sinks/ansicolor_sink.cpp

@@ -109,7 +109,6 @@ template <typename Mutex>
 ansicolor_stderr_sink<Mutex>::ansicolor_stderr_sink(color_mode mode)
     : ansicolor_sink<Mutex>(stderr, mode) {}
 
-
 }  // namespace sinks
 }  // namespace spdlog
 

src/sinks/async_sink.cpp

@@ -33,7 +33,6 @@ async_sink::async_sink(config async_config)
     });
 }
 
-
 async_sink::~async_sink() {
     try {
         q_->enqueue(async_log_msg(async_log_msg::type::terminate));
@@ -46,13 +45,9 @@ async_sink::~async_sink() {
     }
 }
 
-void async_sink::log(const details::log_msg &msg) {
+void async_sink::log(const details::log_msg &msg) { enqueue_message_(async_log_msg(async_log_msg::type::log, msg)); }
-    enqueue_message_(async_log_msg(async_log_msg::type::log, msg));
-}
 
-void async_sink::flush() {
+void async_sink::flush() { enqueue_message_(details::async_log_msg(async_log_msg::type::flush)); }
-    enqueue_message_(details::async_log_msg(async_log_msg::type::flush));
-}
 
 void async_sink::set_pattern(const std::string &pattern) { set_formatter(std::make_unique<pattern_formatter>(pattern)); }
 
@@ -83,7 +78,8 @@ bool async_sink::wait_all(const std::chrono::milliseconds timeout) const {
 }
 
 void async_sink::wait_all() const {
-    while (!wait_all(std::chrono::milliseconds(10))) { /* empty */ }
+    while (!wait_all(std::chrono::milliseconds(10))) { /* empty */
+    }
 }
 
 size_t async_sink::get_overrun_counter() const { return q_->overrun_counter(); }

src/sinks/base_sink.cpp

@@ -5,6 +5,7 @@
 
 #include <memory>
 #include <mutex>
+
 #include "spdlog/common.h"
 #include "spdlog/pattern_formatter.h"
 

src/sinks/basic_file_sink.cpp

@@ -2,9 +2,11 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
 #include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/common.h"
+
 #include <mutex>
 
+#include "spdlog/common.h"
+
 namespace spdlog {
 namespace sinks {
 
@@ -34,7 +36,6 @@ void basic_file_sink<Mutex>::flush_() {
 }  // namespace sinks
 }  // namespace spdlog
 
-
 // template instantiations
 #include "spdlog/details/null_mutex.h"
 template class SPDLOG_API spdlog::sinks::basic_file_sink<std::mutex>;

src/sinks/wincolor_sink.cpp

@@ -8,6 +8,7 @@
 
 // clang-format on
 #include "spdlog/sinks/wincolor_sink.h"
+
 #include "spdlog/common.h"
 
 namespace spdlog {
@@ -131,7 +132,6 @@ template <typename Mutex>
 wincolor_stderr_sink<Mutex>::wincolor_stderr_sink(color_mode mode)
     : wincolor_sink<Mutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {}
 
-
 }  // namespace sinks
 }  // namespace spdlog
 

src/spdlog.cpp

@@ -13,21 +13,17 @@
 
 namespace spdlog {
 
-
 #ifndef SPDLOG_DISABLE_GLOBAL_LOGGER
 static std::shared_ptr<logger> s_logger = std::make_shared<logger>("", std::make_shared<sinks::stdout_color_sink_mt>());
 #else
 static std::short_ptr<logger> s_logger = nullptr;
 #endif
 
-
 std::shared_ptr<logger> global_logger() { return s_logger; }
 
 void set_global_logger(std::shared_ptr<logger> global_logger) { s_logger = std::move(global_logger); }
 
-logger *global_logger_raw() noexcept {
+logger *global_logger_raw() noexcept { return s_logger.get(); }
-    return s_logger.get();
-}
 
 void set_formatter(std::unique_ptr<formatter> formatter) { global_logger()->set_formatter(std::move(formatter)); }
 

tests/test_async.cpp

@@ -71,7 +71,6 @@ TEST_CASE("discard policy discard_new ", "[async]") {
     auto as = std::make_shared<async_sink>(config);
     auto logger = std::make_shared<spdlog::logger>("async_logger", as);
 
-
     REQUIRE(as->get_config().policy == async_sink::overflow_policy::discard_new);
     REQUIRE(as->get_discard_counter() == 0);
     REQUIRE(as->get_overrun_counter() == 0);
@@ -167,7 +166,6 @@ TEST_CASE("to_file", "[async]") {
     REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol)));
 }
 
-
 TEST_CASE("bad_ctor", "[async]") {
     async_sink::config cfg;
     cfg.queue_size = 0;

tests/test_errors.cpp

@@ -18,7 +18,6 @@ protected:
 };
 struct custom_ex {};
 
-
 using namespace spdlog::sinks;
 TEST_CASE("default_error_handler", "[errors]") {
     prepare_logdir();
@@ -36,9 +35,7 @@ TEST_CASE("custom_error_handler", "[errors]") {
     prepare_logdir();
     auto logger = spdlog::create<basic_file_sink_mt>("test-format-error", log_filename);
     logger->flush_on(spdlog::level::info);
-    logger->set_error_handler([=](const std::string & msg) {
+    logger->set_error_handler([=](const std::string &msg) { REQUIRE(msg == "argument not found"); });
-        REQUIRE(msg == "argument not found");
-    });
     logger->info("Good message #1");
     REQUIRE_NOTHROW(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"));
     logger->info("Good message #2");

tests/test_sink.h

@@ -6,9 +6,9 @@
 #pragma once
 
 #include <chrono>
+#include <exception>
 #include <mutex>
 #include <thread>
-#include <exception>
 
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/details/os.h"
@@ -37,13 +37,9 @@ public:
         delay_ = delay;
     }
 
-    void set_exception(const std::runtime_error& ex) {
+    void set_exception(const std::runtime_error& ex) { exception_ptr_ = std::make_exception_ptr(ex); }
-        exception_ptr_ = std::make_exception_ptr(ex);
-    }
 
-    void clear_exception() {
+    void clear_exception() { exception_ptr_ = nullptr; }
-        exception_ptr_ = nullptr;
-    }
 
     // return last output without the eol
     std::vector<std::string> lines() {