clang-format

example/example.cpp

@@ -284,7 +284,9 @@ public:
     }
 
     [[nodiscard]]
-    std::unique_ptr<custom_flag_formatter> clone() const override { return std::make_unique<my_formatter_flag>(); }
+    std::unique_ptr<custom_flag_formatter> clone() const override {
+        return std::make_unique<my_formatter_flag>();
+    }
 };
 
 void custom_flags_example() {

include/spdlog/common.h

@@ -16,7 +16,6 @@
 
 #include "./source_loc.h"
 
-
 #if defined(SPDLOG_SHARED_LIB)
     #if defined(_WIN32)
         #ifdef spdlog_EXPORTS

include/spdlog/details/os.h

@@ -80,7 +80,6 @@ SPDLOG_API bool in_terminal(FILE *file) noexcept;
 SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
 #endif
 
-
 // Return directory name from given path or empty string
 // "abc/file" => "abc"
 // "abc/" => "abc"
@@ -100,7 +99,6 @@ SPDLOG_API std::string getenv(const char *field);
 // Return true on success.
 SPDLOG_API bool fsync(FILE *fp);
 
-
 // Do non-locking fwrite if possible by the os or use the regular locking fwrite
 // Return true on success.
 SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);

include/spdlog/logger.h

@@ -22,7 +22,6 @@
 #include "./details/log_msg.h"
 #include "./sinks/sink.h"
 
-
 #define SPDLOG_LOGGER_CATCH(location)                                                                                     \
     catch (const std::exception &ex) {                                                                                    \
         if (!location.empty()) {                                                                                          \
@@ -36,7 +35,6 @@
         throw;                                                                                                            \
     }
 
-
 namespace spdlog {
 
 class SPDLOG_API logger {
@@ -197,7 +195,9 @@ protected:
         assert(should_log(msg.log_level));
         for (auto &sink : sinks_) {
             if (sink->should_log(msg.log_level)) {
-                try { sink->log(msg); }
+                try {
+                    sink->log(msg);
+                }
                 SPDLOG_LOGGER_CATCH(msg.source)
             }
         }

include/spdlog/sinks/systemd_sink.h

@@ -68,17 +68,14 @@ protected:
         if (msg.source.empty()) {
             // Note: function call inside '()' to avoid macro expansion
             err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d",
-                                    syslog_level(msg.log_level),
+                                    syslog_level(msg.log_level), "TID=%zu", msg.thread_id, "SYSLOG_IDENTIFIER=%.*s",
-                                    "TID=%zu", msg.thread_id,
+                                    static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), nullptr);
-                                    "SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()),
-                                    syslog_identifier.data(), nullptr);
         } else {
             err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d",
-                                    syslog_level(msg.log_level),
+                                    syslog_level(msg.log_level), "TID=%zu", msg.thread_id, "SYSLOG_IDENTIFIER=%.*s",
-                                    "TID=%zu", msg.thread_id,
+                                    static_cast<int>(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s",
-                                    "SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()),
+                                    msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname,
-                                    syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, "CODE_LINE=%d",
+                                    nullptr);
-                                    msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr);
         }
 
         if (err) {

src/async_logger.cpp

@@ -51,7 +51,9 @@ void spdlog::async_logger::flush_() {
 void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
     for (auto &sink : sinks_) {
         if (sink->should_log(msg.log_level)) {
-            try { sink->log(msg); }
+            try {
+                sink->log(msg);
+            }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
@@ -63,7 +65,9 @@ void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
 
 void spdlog::async_logger::backend_flush_() {
     for (auto &sink : sinks_) {
-        try { sink->flush(); }
+        try {
+            sink->flush();
+        }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }

src/details/log_msg.cpp

@@ -16,7 +16,6 @@ log_msg::log_msg(spdlog::log_clock::time_point log_time,
     : logger_name(a_logger_name),
       log_level(lvl),
       time(log_time),
-
 #ifdef SPDLOG_NO_THREAD_ID
       thread_id(0),
 #else

src/details/os_unix.cpp

@@ -326,10 +326,8 @@ std::string getenv(const char *field) {
 // Return true on success
 bool fsync(FILE *fp) { return ::fsync(fileno(fp)) == 0; }
 
-
 // Non locking ::fwrite if possible (SPDLOG_FWRITE_UNLOCKED defined) or use the regular locking fwrite
-bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp)
+bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
-{
 #if defined(SPDLOG_FWRITE_UNLOCKED)
     return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes;
 #else

src/details/os_windows.cpp

@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cassert>
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
@@ -23,7 +24,6 @@
 #include <ctime>
 #include <string>
 #include <thread>
-#include <cassert>
 
 #include "spdlog/common.h"
 #include "spdlog/details/os.h"
@@ -76,9 +76,7 @@ bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
     return *fp == nullptr;
 }
 
-int remove(const filename_t &filename) noexcept {
+int remove(const filename_t &filename) noexcept { return std::remove(filename.c_str()); }
-    return std::remove(filename.c_str());
-}
 
 int remove_if_exists(const filename_t &filename) noexcept { return path_exists(filename) ? remove(filename) : 0; }
 
@@ -169,7 +167,6 @@ bool is_color_terminal() noexcept { return true; }
 // Determine if the terminal attached
 bool in_terminal(FILE *file) noexcept { return ::_isatty(_fileno(file)) != 0; }
 
-
 void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
     if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 4 - 1) {
         throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
@@ -183,14 +180,12 @@ void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
 
     int result_size = static_cast<int>(target.capacity());
     if ((wstr_size + 1) * 4 > result_size) {
-        result_size =
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
-            ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
     }
 
     if (result_size > 0) {
         target.resize(result_size);
-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(),
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
-                                            result_size, NULL, NULL);
 
         if (result_size > 0) {
             target.resize(result_size);
@@ -198,8 +193,7 @@ void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) {
         }
     }
 
-    throw_spdlog_ex(
+    throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
-        fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
 }
 
 void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
@@ -214,27 +208,22 @@ void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
     }
 
     // find the size to allocate for the result buffer
-    int result_size =
+    int result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
-        ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0);
 
     if (result_size > 0) {
         target.resize(result_size);
-        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(),
+        result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(), result_size);
-                                            result_size);
         if (result_size > 0) {
             assert(result_size == target.size());
             return;
         }
     }
 
-    throw_spdlog_ex(
+    throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
-        fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
 }
 
 // return true on success
-static bool mkdir_(const filename_t &path) {
+static bool mkdir_(const filename_t &path) { return ::_mkdir(path.c_str()) == 0; }
-    return ::_mkdir(path.c_str()) == 0;
-}
 
 // create the given directory - and all directories leading to it
 // return true on success or if the directory already exists
@@ -305,8 +294,7 @@ std::string getenv(const char *field) {
 bool fsync(FILE *fp) { return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0; }
 
 // Non locking fwrite if possible (SPDLOG_FWRITE_UNLOCKED defined) or use the regular locking fwrite
-bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp)
+bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) {
-{
 #if defined(SPDLOG_FWRITE_UNLOCKED)
     return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes;
 #else

src/details/thread_pool.cpp

@@ -45,8 +45,8 @@ thread_pool::~thread_pool() {
         for (auto &t : threads_) {
             t.join();
         }
+    } catch (...) {
     }
-    catch (...) {}
 }
 
 void thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) {

src/logger.cpp

@@ -75,7 +75,9 @@ std::shared_ptr<logger> logger::clone(std::string logger_name) {
 // private/protected methods
 void logger::flush_() {
     for (auto &sink : sinks_) {
-        try { sink->flush(); }
+        try {
+            sink->flush();
+        }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }

src/pattern_formatter.cpp

@@ -148,7 +148,8 @@ public:
 };
 
 // Full weekday name
-static constexpr std::array<const char *, 7> full_days{{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}};
+static constexpr std::array<const char *, 7> full_days{
+    {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}};
 
 template <typename ScopedPadder>
 class A_formatter final : public flag_formatter {

src/sinks/sink.cpp

@@ -11,6 +11,4 @@ bool spdlog::sinks::sink::should_log(spdlog::level msg_level) const {
 
 void spdlog::sinks::sink::set_level(level level) { level_.store(level, std::memory_order_relaxed); }
 
-spdlog::level spdlog::sinks::sink::log_level() const {
+spdlog::level spdlog::sinks::sink::log_level() const { return level_.load(std::memory_order_relaxed); }
-    return level_.load(std::memory_order_relaxed);
-}

src/sinks/stdout_sinks.cpp

@@ -1,12 +1,12 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
+#include "spdlog/sinks/stdout_sinks.h"
 
 #include <memory>
 
-#include "spdlog/pattern_formatter.h"
-#include "spdlog/sinks/stdout_sinks.h"
 #include "spdlog/details/os.h"
+#include "spdlog/pattern_formatter.h"
 
 // clang-format off
 #ifdef _WIN32

tests/test_daily_and_rotation_loggers.cpp

@@ -8,7 +8,6 @@
 
 using filename_memory_buf_t = spdlog::memory_buf_t;
 
-
 TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") {
     using sink_type = spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>;
 

tests/test_misc.cpp

@@ -4,11 +4,11 @@
 
 #include <cstdio>
 #include <cstring>
-#include "includes.h"
-#include "spdlog/sinks/ostream_sink.h"
-#include "spdlog/details/os.h"
-#include "test_sink.h"
 
+#include "includes.h"
+#include "spdlog/details/os.h"
+#include "spdlog/sinks/ostream_sink.h"
+#include "test_sink.h"
 
 template <class T>
 std::string log_info(const T& what, spdlog::level logger_level = spdlog::level::info) {
@@ -186,7 +186,8 @@ TEST_CASE("utf8 to utf16 conversion using windows api", "[windows utf]") {
 
 struct auto_closer {
     FILE* fp = nullptr;
-    explicit auto_closer(FILE* f) : fp(f) {}
+    explicit auto_closer(FILE* f)
+        : fp(f) {}
     auto_closer(const auto_closer&) = delete;
     auto_closer& operator=(const auto_closer&) = delete;
     ~auto_closer() {
@@ -194,11 +195,9 @@ struct auto_closer {
     }
 };
 
-
 TEST_CASE("os::fwrite_bytes", "[os]") {
-
-    using spdlog::details::os::fwrite_bytes;
     using spdlog::details::os::create_dir;
+    using spdlog::details::os::fwrite_bytes;
     const char* filename = "log_tests/test_fwrite_bytes.txt";
     const char* msg = "hello";
     prepare_logdir();