From 6dffd7c6e84702ca5895baebea61f8eae4fa88c8 Mon Sep 17 00:00:00 2001 From: gabime Date: Mon, 25 Sep 2023 16:40:05 +0300 Subject: [PATCH] update clang format again --- .clang-format | 2 +- bench/async_bench.cpp | 17 +- bench/bench.cpp | 3 +- bench/formatter-bench.cpp | 1 - bench/latency.cpp | 12 +- bench/utils.h | 2 +- example/example.cpp | 17 +- include/spdlog/async.h | 7 +- include/spdlog/async_logger.h | 10 +- include/spdlog/cfg/argv.h | 4 +- include/spdlog/cfg/env.h | 4 +- include/spdlog/cfg/helpers.h | 6 +- include/spdlog/common.h | 44 +- include/spdlog/details/circular_q.h | 8 +- include/spdlog/details/console_globals.h | 4 +- include/spdlog/details/file_helper.h | 4 +- include/spdlog/details/fmt_helper.h | 22 +- include/spdlog/details/log_msg.h | 4 +- include/spdlog/details/log_msg_buffer.h | 4 +- include/spdlog/details/mpmc_blocking_q.h | 4 +- include/spdlog/details/null_mutex.h | 6 +- include/spdlog/details/os.h | 8 +- include/spdlog/details/periodic_worker.h | 6 +- include/spdlog/details/registry.h | 4 +- include/spdlog/details/synchronous_factory.h | 2 +- include/spdlog/details/tcp_client-windows.h | 12 +- include/spdlog/details/tcp_client.h | 12 +- include/spdlog/details/thread_pool.h | 6 +- include/spdlog/details/udp_client-windows.h | 4 +- include/spdlog/details/udp_client.h | 4 +- include/spdlog/details/windows_include.h | 2 +- include/spdlog/fmt/bin_to_hex.h | 55 +-- include/spdlog/fmt/fmt.h | 4 +- include/spdlog/formatter.h | 2 +- include/spdlog/fwd.h | 2 +- include/spdlog/logger.h | 4 +- include/spdlog/pattern_formatter.h | 9 +- include/spdlog/sinks/android_sink.h | 44 +- include/spdlog/sinks/ansicolor_sink.h | 4 +- include/spdlog/sinks/base_sink.h | 4 +- include/spdlog/sinks/basic_file_sink.h | 4 +- include/spdlog/sinks/callback_sink.h | 4 +- include/spdlog/sinks/daily_file_sink.h | 36 +- include/spdlog/sinks/dist_sink.h | 4 +- include/spdlog/sinks/dup_filter_sink.h | 4 +- include/spdlog/sinks/hourly_file_sink.h | 4 +- include/spdlog/sinks/kafka_sink.h | 12 +- include/spdlog/sinks/mongo_sink.h | 24 +- include/spdlog/sinks/msvc_sink.h | 6 +- include/spdlog/sinks/null_sink.h | 4 +- include/spdlog/sinks/ostream_sink.h | 4 +- include/spdlog/sinks/qt_sinks.h | 30 +- include/spdlog/sinks/ringbuffer_sink.h | 4 +- include/spdlog/sinks/rotating_file_sink.h | 4 +- include/spdlog/sinks/sink.h | 4 +- include/spdlog/sinks/stdout_color_sinks.h | 4 +- include/spdlog/sinks/stdout_sinks.h | 6 +- include/spdlog/sinks/syslog_sink.h | 5 +- include/spdlog/sinks/systemd_sink.h | 4 +- include/spdlog/sinks/tcp_sink.h | 6 +- include/spdlog/sinks/udp_sink.h | 4 +- include/spdlog/sinks/win_eventlog_sink.h | 39 +- include/spdlog/sinks/wincolor_sink.h | 4 +- include/spdlog/spdlog.h | 4 +- include/spdlog/stopwatch.h | 4 +- src/cfg/helpers.cpp | 8 +- src/common.cpp | 2 +- src/details/file_helper.cpp | 4 +- src/details/log_msg.cpp | 4 +- src/details/log_msg_buffer.cpp | 4 +- src/details/os.cpp | 66 ++- src/details/periodic_worker.cpp | 4 +- src/details/registry.cpp | 9 +- src/details/thread_pool.cpp | 37 +- src/fmt/bundled_fmtlib_format.cpp | 10 +- src/logger.cpp | 6 +- src/pattern_formatter.cpp | 414 ++++++++++--------- src/sinks/ansicolor_sink.cpp | 30 +- src/sinks/basic_file_sink.cpp | 4 +- src/sinks/rotating_file_sink.cpp | 13 +- src/sinks/stdout_color_sinks.cpp | 18 +- src/sinks/stdout_sinks.cpp | 36 +- src/sinks/wincolor_sink.cpp | 22 +- src/spdlog.cpp | 2 +- tests/includes.h | 2 +- tests/main.cpp | 2 +- tests/test_async.cpp | 1 - tests/test_circular_q.cpp | 4 +- tests/test_create_dir.cpp | 2 +- tests/test_daily_logger.cpp | 1 - tests/test_dup_filter.cpp | 2 +- tests/test_errors.cpp | 11 +- tests/test_eventlog.cpp | 2 +- tests/test_file_logging.cpp | 1 - tests/test_macros.cpp | 1 - tests/test_misc.cpp | 1 - tests/test_mpmc_q.cpp | 6 +- tests/test_ringbuffer_sink.cpp | 4 +- tests/test_sink.h | 4 +- tests/test_time_point.cpp | 4 +- tests/utils.cpp | 11 +- 101 files changed, 667 insertions(+), 686 deletions(-) diff --git a/.clang-format b/.clang-format index c605698e..c8c345f6 100644 --- a/.clang-format +++ b/.clang-format @@ -1,6 +1,6 @@ --- Language: Cpp -# BasedOnStyle: Google +BasedOnStyle: Google AccessModifierOffset: -4 Standard: c++17 IndentWidth: 4 diff --git a/bench/async_bench.cpp b/bench/async_bench.cpp index 8d4d8106..a136c7bd 100644 --- a/bench/async_bench.cpp +++ b/bench/async_bench.cpp @@ -35,16 +35,15 @@ void bench_mt(int howmany, std::shared_ptr log, int thread_count #ifdef _MSC_VER #pragma warning(push) - #pragma warning(disable : 4996) // disable fopen warning under msvc -#endif // _MSC_VER + #pragma warning(disable : 4996) // disable fopen warning under msvc +#endif // _MSC_VER int count_lines(const char *filename) { int counter = 0; auto *infile = fopen(filename, "r"); int ch; while (EOF != (ch = getc(infile))) { - if ('\n' == ch) - counter++; + if ('\n' == ch) counter++; } fclose(infile); @@ -67,7 +66,6 @@ void verify_file(const char *filename, int expected_count) { #endif int main(int argc, char *argv[]) { - int howmany = 1000000; int queue_size = std::min(howmany + 2, 8192); int threads = 10; @@ -80,10 +78,8 @@ int main(int argc, char *argv[]) { return 0; } - if (argc > 1) - howmany = atoi(argv[1]); - if (argc > 2) - threads = atoi(argv[2]); + if (argc > 1) howmany = atoi(argv[1]); + if (argc > 2) threads = atoi(argv[2]); if (argc > 3) { queue_size = atoi(argv[3]); if (queue_size > 500000) { @@ -92,8 +88,7 @@ int main(int argc, char *argv[]) { } } - if (argc > 4) - iters = atoi(argv[4]); + if (argc > 4) iters = atoi(argv[4]); auto slot_size = sizeof(spdlog::details::async_msg); spdlog::info("-------------------------------------------------"); diff --git a/bench/bench.cpp b/bench/bench.cpp index 8e6f07c3..d370dd63 100644 --- a/bench/bench.cpp +++ b/bench/bench.cpp @@ -22,7 +22,7 @@ #include "utils.h" #include -#include // EXIT_FAILURE +#include // EXIT_FAILURE #include #include #include @@ -91,7 +91,6 @@ int main(int argc, char *argv[]) { int iters = 250000; size_t threads = 4; try { - if (argc > 1) { iters = std::stoi(argv[1]); } diff --git a/bench/formatter-bench.cpp b/bench/formatter-bench.cpp index 8f5bb4b9..8e88b92f 100644 --- a/bench/formatter-bench.cpp +++ b/bench/formatter-bench.cpp @@ -54,7 +54,6 @@ void bench_formatters() { } int main(int argc, char *argv[]) { - spdlog::set_pattern("[%^%l%$] %v"); if (argc != 2) { spdlog::error("Usage: {} (or \"all\" to bench all)", argv[0]); diff --git a/bench/latency.cpp b/bench/latency.cpp index d741af23..20c24dfa 100644 --- a/bench/latency.cpp +++ b/bench/latency.cpp @@ -49,8 +49,8 @@ void bench_global_logger(benchmark::State &state, std::shared_ptr logger) { int i = 0; - benchmark::DoNotOptimize(i); // prevent unused warnings - benchmark::DoNotOptimize(logger); // prevent unused warnings + benchmark::DoNotOptimize(i); // prevent unused warnings + benchmark::DoNotOptimize(logger); // prevent unused warnings for (auto _ : state) { SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++); } @@ -60,8 +60,8 @@ void bench_disabled_macro_global_logger(benchmark::State &state, std::shared_ptr logger) { spdlog::set_default_logger(std::move(logger)); int i = 0; - benchmark::DoNotOptimize(i); // prevent unused warnings - benchmark::DoNotOptimize(logger); // prevent unused warnings + benchmark::DoNotOptimize(i); // prevent unused warnings + benchmark::DoNotOptimize(logger); // prevent unused warnings for (auto _ : state) { SPDLOG_DEBUG("Hello logger: msg number {}...............", i++); } @@ -79,7 +79,7 @@ void bench_dev_null() { ->UseRealTime(); spdlog::drop("/dev/null_mt"); } -#endif // __linux__ +#endif // __linux__ int main(int argc, char *argv[]) { using spdlog::sinks::null_sink_mt; @@ -112,7 +112,7 @@ int main(int argc, char *argv[]) { #ifdef __linux bench_dev_null(); -#endif // __linux__ +#endif // __linux__ if (full_bench) { // basic_st diff --git a/bench/utils.h b/bench/utils.h index 0f52e700..1828fc08 100644 --- a/bench/utils.h +++ b/bench/utils.h @@ -29,4 +29,4 @@ inline std::string format(const double &value) { return ss.str(); } -} // namespace utils +} // namespace utils diff --git a/example/example.cpp b/example/example.cpp index 7d291ccd..126580a7 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -32,7 +32,7 @@ void replace_default_logger_example(); // #define SPDLOG_SOURCE_LOCATION #include "spdlog/spdlog.h" -#include "spdlog/cfg/env.h" // support for loading levels from the environment variable +#include "spdlog/cfg/env.h" // support for loading levels from the environment variable int main(int, char *[]) { // Log levels can be loaded from argv/env using "SPDLOG_LEVEL" @@ -47,15 +47,15 @@ int main(int, char *[]) { spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left"); // Runtime log levels - spdlog::set_level(spdlog::level::info); // Set global log level to info + spdlog::set_level(spdlog::level::info); // Set global log level to info spdlog::debug("This message should not be displayed!"); - spdlog::set_level(spdlog::level::trace); // Set specific logger's log level + spdlog::set_level(spdlog::level::trace); // Set specific logger's log level spdlog::debug("This message should be displayed.."); // Customize msg format for all loggers spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v"); spdlog::info("This an info message with custom format"); - spdlog::set_pattern("%+"); // back to default format + spdlog::set_pattern("%+"); // back to default format spdlog::set_level(spdlog::level::info); try { @@ -259,7 +259,7 @@ struct my_type { : i(i){}; }; -#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib +#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib template <> struct fmt::formatter : fmt::formatter { auto format(my_type my, format_context &ctx) -> decltype(ctx.out()) { @@ -267,7 +267,7 @@ struct fmt::formatter : fmt::formatter { } }; -#else // when using std::format +#else // when using std::format template <> struct std::formatter : std::formatter { auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) { @@ -311,8 +311,9 @@ void android_example() { #include "spdlog/pattern_formatter.h" class my_formatter_flag : public spdlog::custom_flag_formatter { public: - void - format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override { + void format(const spdlog::details::log_msg &, + const std::tm &, + spdlog::memory_buf_t &dest) override { std::string some_txt = "custom-flag"; dest.append(some_txt.data(), some_txt.data() + some_txt.size()); } diff --git a/include/spdlog/async.h b/include/spdlog/async.h index 76b93ed9..e96abd19 100644 --- a/include/spdlog/async.h +++ b/include/spdlog/async.h @@ -82,8 +82,9 @@ inline void init_thread_pool(size_t q_size, details::registry::instance().set_tp(std::move(tp)); } -inline void -init_thread_pool(size_t q_size, size_t thread_count, std::function on_thread_start) { +inline void init_thread_pool(size_t q_size, + size_t thread_count, + std::function on_thread_start) { init_thread_pool(q_size, thread_count, on_thread_start, [] {}); } @@ -96,4 +97,4 @@ inline void init_thread_pool(size_t q_size, size_t thread_count) { inline std::shared_ptr thread_pool() { return details::registry::instance().get_tp(); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index 6695be88..299e59dc 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -20,10 +20,10 @@ namespace spdlog { // Async overflow policy - block by default. 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. - discard_new // Discard new message if the queue is full when trying to add new item. + block, // Block until message can be enqueued + overrun_oldest, // Discard oldest message in the queue if full when trying to + // add new item. + discard_new // Discard new message if the queue is full when trying to add new item. }; namespace details { @@ -67,4 +67,4 @@ private: std::weak_ptr thread_pool_; async_overflow_policy overflow_policy_; }; -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/cfg/argv.h b/include/spdlog/cfg/argv.h index 8610e3ab..7de2f83e 100644 --- a/include/spdlog/cfg/argv.h +++ b/include/spdlog/cfg/argv.h @@ -36,5 +36,5 @@ inline void load_argv_levels(int argc, char **argv) { load_argv_levels(argc, const_cast(argv)); } -} // namespace cfg -} // namespace spdlog +} // namespace cfg +} // namespace spdlog diff --git a/include/spdlog/cfg/env.h b/include/spdlog/cfg/env.h index e445a1c6..6e554145 100644 --- a/include/spdlog/cfg/env.h +++ b/include/spdlog/cfg/env.h @@ -32,5 +32,5 @@ inline void load_env_levels() { } } -} // namespace cfg -} // namespace spdlog +} // namespace cfg +} // namespace spdlog diff --git a/include/spdlog/cfg/helpers.h b/include/spdlog/cfg/helpers.h index 74d66c09..d43ef3b1 100644 --- a/include/spdlog/cfg/helpers.h +++ b/include/spdlog/cfg/helpers.h @@ -19,6 +19,6 @@ namespace helpers { // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" // SPDLOG_API void load_levels(const std::string &txt); -} // namespace helpers -} // namespace cfg -} // namespace spdlog +} // namespace helpers +} // namespace cfg +} // namespace spdlog diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 68783472..e4bb6e92 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -41,20 +41,20 @@ #if defined(_WIN32) #ifdef spdlog_EXPORTS #define SPDLOG_API __declspec(dllexport) - #else // !spdlog_EXPORTS + #else // !spdlog_EXPORTS #define SPDLOG_API __declspec(dllimport) #endif - #else // !defined(_WIN32) + #else // !defined(_WIN32) #define SPDLOG_API __attribute__((visibility("default"))) #endif -#else // !defined(SPDLOG_SHARED_LIB) +#else // !defined(SPDLOG_SHARED_LIB) #define SPDLOG_API #endif #include #if !defined(SPDLOG_USE_STD_FORMAT) && \ - FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 + FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) #if defined(SPDLOG_WCHAR_FILENAMES) #include @@ -121,7 +121,7 @@ using format_string_t = std::string_view; #endif #define SPDLOG_BUF_TO_STRING(x) x -#else // use fmt lib instead of std::format +#else // use fmt lib instead of std::format namespace fmt_lib = fmt; using string_view_t = fmt::basic_string_view; @@ -131,7 +131,7 @@ using format_string_t = fmt::format_string; using wstring_view_t = fmt::basic_string_view; using wmemory_buf_t = fmt::basic_memory_buffer; #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) -#endif // SPDLOG_USE_STD_FORMAT +#endif // SPDLOG_USE_STD_FORMAT #define SPDLOG_LEVEL_TRACE 0 #define SPDLOG_LEVEL_DEBUG 1 @@ -204,8 +204,8 @@ enum class color_mode { always, automatic, never }; // local time by default // enum class pattern_time_type { - local, // log localtime - utc // log utc + local, // log localtime + utc // log utc }; // @@ -234,8 +234,8 @@ struct source_loc { funcname{funcname_in} {} #ifdef SPDLOG_HAVE_STD_SOURCE_LOCATION - static constexpr source_loc - current(const std::source_location source_location = std::source_location::current()) { + static constexpr source_loc current( + const std::source_location source_location = std::source_location::current()) { return source_loc{source_location.file_name(), source_location.line(), source_location.function_name()}; } @@ -245,7 +245,7 @@ struct source_loc { return source_loc{source_location.file_name(), source_location.line(), source_location.function_name()}; } -#else // no source location support +#else // no source location support static constexpr source_loc current() { return source_loc{}; } #endif @@ -310,26 +310,26 @@ namespace details { // convert format_string<...> to string_view depending on format lib versions #if defined(SPDLOG_USE_STD_FORMAT) - #if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L + #if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L template -[[nodiscard]] constexpr std::basic_string_view -to_string_view(std::basic_format_string fmt) noexcept { +[[nodiscard]] constexpr std::basic_string_view to_string_view( + std::basic_format_string fmt) noexcept { return fmt.get(); } - #else // std::format and __cpp_lib_format < 202207L + #else // std::format and __cpp_lib_format < 202207L template -[[nodiscard]] constexpr std::basic_string_view -to_string_view(std::basic_format_string fmt) noexcept { +[[nodiscard]] constexpr std::basic_string_view to_string_view( + std::basic_format_string fmt) noexcept { return fmt; } #endif -#else // {fmt} version +#else // {fmt} version template -[[nodiscard]] constexpr fmt::basic_string_view -to_string_view(fmt::basic_format_string fmt) noexcept { +[[nodiscard]] constexpr fmt::basic_string_view to_string_view( + fmt::basic_format_string fmt) noexcept { return fmt; } #endif -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/circular_q.h b/include/spdlog/details/circular_q.h index b030e65f..4fbb2eea 100644 --- a/include/spdlog/details/circular_q.h +++ b/include/spdlog/details/circular_q.h @@ -24,7 +24,7 @@ public: circular_q() = default; explicit circular_q(size_t max_items) - : max_items_(max_items + 1) // one item is reserved as marker for full q + : max_items_(max_items + 1) // one item is reserved as marker for full q , v_(max_items_) {} @@ -46,7 +46,7 @@ public: v_[tail_] = std::move(item); tail_ = (tail_ + 1) % max_items_; - if (tail_ == head_) // overrun last item if full + if (tail_ == head_) // overrun last item if full { head_ = (head_ + 1) % max_items_; ++overrun_counter_; @@ -115,5 +115,5 @@ private: other.overrun_counter_ = 0; } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/console_globals.h b/include/spdlog/details/console_globals.h index 649afb3e..9c552106 100644 --- a/include/spdlog/details/console_globals.h +++ b/include/spdlog/details/console_globals.h @@ -24,5 +24,5 @@ struct console_nullmutex { return s_mutex; } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index db4a9b03..50ebf61f 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -53,5 +53,5 @@ private: filename_t filename_; file_event_handlers event_handlers_; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h index f8aabf43..62812d72 100644 --- a/include/spdlog/details/fmt_helper.h +++ b/include/spdlog/details/fmt_helper.h @@ -53,14 +53,10 @@ constexpr unsigned int count_digits_fallback(T n) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. - if (n < 10) - return count; - if (n < 100) - return count + 1; - if (n < 1000) - return count + 2; - if (n < 10000) - return count + 3; + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; n /= 10000u; count += 4; } @@ -86,11 +82,11 @@ inline unsigned int count_digits(T n) { } inline void pad2(int n, memory_buf_t &dest) { - if (n >= 0 && n < 100) // 0-99 + if (n >= 0 && n < 100) // 0-99 { dest.push_back(static_cast('0' + n / 10)); dest.push_back(static_cast('0' + n % 10)); - } else // unlikely, but just in case, let fmt deal with it + } else // unlikely, but just in case, let fmt deal with it { fmt_lib::format_to(std::back_inserter(dest), "{:02}", n); } @@ -140,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp) { return duration_cast(duration) - duration_cast(secs); } -} // namespace fmt_helper -} // namespace details -} // namespace spdlog +} // namespace fmt_helper +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index c59d6337..581be209 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -32,5 +32,5 @@ struct SPDLOG_API log_msg { source_loc source; string_view_t payload; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/log_msg_buffer.h b/include/spdlog/details/log_msg_buffer.h index f8492e3e..e7057836 100644 --- a/include/spdlog/details/log_msg_buffer.h +++ b/include/spdlog/details/log_msg_buffer.h @@ -24,5 +24,5 @@ public: log_msg_buffer &operator=(log_msg_buffer &&other) noexcept; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/mpmc_blocking_q.h b/include/spdlog/details/mpmc_blocking_q.h index 1780284d..5a474bf3 100644 --- a/include/spdlog/details/mpmc_blocking_q.h +++ b/include/spdlog/details/mpmc_blocking_q.h @@ -173,5 +173,5 @@ private: spdlog::details::circular_q q_; std::atomic discard_counter_{0}; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/null_mutex.h b/include/spdlog/details/null_mutex.h index aee2e2f4..47b9845b 100644 --- a/include/spdlog/details/null_mutex.h +++ b/include/spdlog/details/null_mutex.h @@ -30,9 +30,9 @@ struct null_atomic { T exchange(T new_value, std::memory_order = std::memory_order_seq_cst) { std::swap(new_value, value); - return new_value; // return value before the call + return new_value; // return value before the call } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index ccd14435..a63b0179 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -3,7 +3,7 @@ #pragma once -#include // std::time_t +#include // std::time_t #include namespace spdlog { @@ -114,6 +114,6 @@ SPDLOG_API std::string getenv(const char *field); // Return true on success. SPDLOG_API bool fsync(FILE *fp); -} // namespace os -} // namespace details -} // namespace spdlog +} // namespace os +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/periodic_worker.h b/include/spdlog/details/periodic_worker.h index 6e584715..9866a509 100644 --- a/include/spdlog/details/periodic_worker.h +++ b/include/spdlog/details/periodic_worker.h @@ -35,7 +35,7 @@ public: for (;;) { std::unique_lock lock(this->mutex_); if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { - return; // active_ == false, so exit this thread + return; // active_ == false, so exit this thread } callback_fun(); } @@ -53,5 +53,5 @@ private: std::condition_variable cv_; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 99fc5201..f1f8b5cf 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -109,5 +109,5 @@ private: bool automatic_registration_ = true; }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/synchronous_factory.h b/include/spdlog/details/synchronous_factory.h index 21ded285..4bd5a51c 100644 --- a/include/spdlog/details/synchronous_factory.h +++ b/include/spdlog/details/synchronous_factory.h @@ -19,4 +19,4 @@ struct synchronous_factory { return new_logger; } }; -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/details/tcp_client-windows.h b/include/spdlog/details/tcp_client-windows.h index e74efa09..bf8f7b87 100644 --- a/include/spdlog/details/tcp_client-windows.h +++ b/include/spdlog/details/tcp_client-windows.h @@ -66,9 +66,9 @@ public: struct addrinfo hints {}; ZeroMemory(&hints, sizeof(hints)); - hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on - hints.ai_socktype = SOCK_STREAM; // TCP - hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value + hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_protocol = 0; auto port_str = std::to_string(port); @@ -123,7 +123,7 @@ public: throw_winsock_error_("send failed", last_error); } - if (write_result == 0) // (probably should not happen but in any case..) + if (write_result == 0) // (probably should not happen but in any case..) { break; } @@ -131,5 +131,5 @@ public: } } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/tcp_client.h b/include/spdlog/details/tcp_client.h index c323d78e..9d3c40d5 100644 --- a/include/spdlog/details/tcp_client.h +++ b/include/spdlog/details/tcp_client.h @@ -44,9 +44,9 @@ public: close(); struct addrinfo hints {}; memset(&hints, 0, sizeof(struct addrinfo)); - hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on - hints.ai_socktype = SOCK_STREAM; // TCP - hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value + hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on + hints.ai_socktype = SOCK_STREAM; // TCP + hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_protocol = 0; auto port_str = std::to_string(port); @@ -115,7 +115,7 @@ public: throw_spdlog_ex("write(2) failed", errno); } - if (write_result == 0) // (probably should not happen but in any case..) + if (write_result == 0) // (probably should not happen but in any case..) { break; } @@ -123,5 +123,5 @@ public: } } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h index cc1b486f..58693b53 100644 --- a/include/spdlog/details/thread_pool.h +++ b/include/spdlog/details/thread_pool.h @@ -48,7 +48,7 @@ struct async_msg : log_msg_buffer { worker_ptr = std::move(other.worker_ptr); return *this; } -#else // (_MSC_VER) && _MSC_VER <= 1800 +#else // (_MSC_VER) && _MSC_VER <= 1800 async_msg(async_msg &&) = default; async_msg &operator=(async_msg &&) = default; #endif @@ -110,5 +110,5 @@ private: bool process_next_msg_(); }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/udp_client-windows.h b/include/spdlog/details/udp_client-windows.h index 4d9d96b5..8b7c2232 100644 --- a/include/spdlog/details/udp_client-windows.h +++ b/include/spdlog/details/udp_client-windows.h @@ -94,5 +94,5 @@ public: } } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/udp_client.h b/include/spdlog/details/udp_client.h index 39e4b449..95826f5d 100644 --- a/include/spdlog/details/udp_client.h +++ b/include/spdlog/details/udp_client.h @@ -77,5 +77,5 @@ public: } } }; -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/include/spdlog/details/windows_include.h b/include/spdlog/details/windows_include.h index 43b8958d..bbab59b1 100644 --- a/include/spdlog/details/windows_include.h +++ b/include/spdlog/details/windows_include.h @@ -1,7 +1,7 @@ #pragma once #ifndef NOMINMAX - #define NOMINMAX // prevent windows redefining min/max + #define NOMINMAX // prevent windows redefining min/max #endif #ifndef WIN32_LEAN_AND_MEAN diff --git a/include/spdlog/fmt/bin_to_hex.h b/include/spdlog/fmt/bin_to_hex.h index 110dde2d..e7c3fefb 100644 --- a/include/spdlog/fmt/bin_to_hex.h +++ b/include/spdlog/fmt/bin_to_hex.h @@ -56,7 +56,7 @@ private: It begin_, end_; size_t size_per_line_; }; -} // namespace details +} // namespace details // create a dump_info that wraps the given container template @@ -71,8 +71,8 @@ inline details::dump_info to_hex(const Conta #if __cpp_lib_span >= 202002L template -inline details::dump_info::iterator> -to_hex(const std::span &container, size_t size_per_line = 32) { +inline details::dump_info::iterator> to_hex( + const std::span &container, size_t size_per_line = 32) { using Container = std::span; static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); @@ -84,12 +84,13 @@ to_hex(const std::span &container, size_t size_per_line = 32) { // create dump_info from ranges template -inline details::dump_info -to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) { +inline details::dump_info to_hex(const It range_begin, + const It range_end, + size_t size_per_line = 32) { return details::dump_info(range_begin, range_end, size_per_line); } -} // namespace spdlog +} // namespace spdlog namespace #ifdef SPDLOG_USE_STD_FORMAT @@ -105,7 +106,7 @@ struct formatter, char> { bool put_newlines = true; bool put_delimiters = true; bool use_uppercase = false; - bool put_positions = true; // position on start of each line + bool put_positions = true; // position on start of each line bool show_ascii = false; // parse the format string flags @@ -114,24 +115,24 @@ struct formatter, char> { auto it = ctx.begin(); while (it != ctx.end() && *it != '}') { switch (*it) { - case 'X': - use_uppercase = true; - break; - case 's': - put_delimiters = false; - break; - case 'p': - put_positions = false; - break; - case 'n': - put_newlines = false; - show_ascii = false; - break; - case 'a': - if (put_newlines) { - show_ascii = true; - } - break; + case 'X': + use_uppercase = true; + break; + case 's': + put_delimiters = false; + break; + case 'p': + put_positions = false; + break; + case 'n': + put_newlines = false; + show_ascii = false; + break; + case 'a': + if (put_newlines) { + show_ascii = true; + } + break; } ++it; @@ -185,7 +186,7 @@ struct formatter, char> { *inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[ch & 0x0f]; } - if (show_ascii) // add ascii to last line + if (show_ascii) // add ascii to last line { if (the_range.get_end() - the_range.get_begin() > size_per_line) { auto blank_num = size_per_line - (the_range.get_end() - start_of_line); @@ -220,4 +221,4 @@ struct formatter, char> { } } }; -} // namespace std +} // namespace std diff --git a/include/spdlog/fmt/fmt.h b/include/spdlog/fmt/fmt.h index 2ef740d5..9d986c09 100644 --- a/include/spdlog/fmt/fmt.h +++ b/include/spdlog/fmt/fmt.h @@ -10,12 +10,12 @@ // By default, spdlog include its own copy. // -#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format +#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format #include #elif !defined(SPDLOG_FMT_EXTERNAL) #include #include -#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib +#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib #include #include #endif diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index 7fbd52a5..4d482f82 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -14,4 +14,4 @@ public: virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; virtual std::unique_ptr clone() const = 0; }; -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/fwd.h b/include/spdlog/fwd.h index 3d43cab3..0db7a777 100644 --- a/include/spdlog/fwd.h +++ b/include/spdlog/fwd.h @@ -12,4 +12,4 @@ namespace sinks { class sink; } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index b5176663..593b4a9d 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -266,7 +266,7 @@ protected: #ifdef SPDLOG_USE_STD_FORMAT auto formatted = std::vformat(fmt, std::make_format_args(args...)); sink_it_(details::log_msg(loc, name_, lvl, formatted)); -#else // use {fmt} lib +#else // use {fmt} lib memory_buf_t buf; fmt::vformat_to(std::back_inserter(buf), fmt, fmt::make_format_args(args...)); sink_it_(details::log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()))); @@ -297,4 +297,4 @@ protected: void err_handler_(const std::string &msg); }; -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/pattern_formatter.h b/include/spdlog/pattern_formatter.h index 7b16b808..55479404 100644 --- a/include/spdlog/pattern_formatter.h +++ b/include/spdlog/pattern_formatter.h @@ -43,14 +43,15 @@ public: : padinfo_(padinfo) {} flag_formatter() = default; virtual ~flag_formatter() = default; - virtual void - format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0; + virtual void format(const details::log_msg &msg, + const std::tm &tm_time, + memory_buf_t &dest) = 0; protected: padding_info padinfo_; }; -} // namespace details +} // namespace details class SPDLOG_API custom_flag_formatter : public details::flag_formatter { public: @@ -110,4 +111,4 @@ private: void compile_pattern_(const std::string &pattern); }; -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h index f7e20ede..8a90fb57 100644 --- a/include/spdlog/sinks/android_sink.h +++ b/include/spdlog/sinks/android_sink.h @@ -52,7 +52,7 @@ protected: // See system/core/liblog/logger_write.c for explanation of return value int ret = android_log(priority, tag_.c_str(), msg_output); if (ret == -EPERM) { - return; // !__android_log_is_loggable + return; // !__android_log_is_loggable } int retry_count = 0; while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) { @@ -74,33 +74,33 @@ private: // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, // when using the default log buffer, always log via __android_log_write. template - typename std::enable_if(log_id::LOG_ID_MAIN), int>::type - android_log(int prio, const char *tag, const char *text) { + typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( + int prio, const char *tag, const char *text) { return __android_log_write(prio, tag, text); } template - typename std::enable_if(log_id::LOG_ID_MAIN), int>::type - android_log(int prio, const char *tag, const char *text) { + typename std::enable_if(log_id::LOG_ID_MAIN), int>::type android_log( + int prio, const char *tag, const char *text) { return __android_log_buf_write(ID, prio, tag, text); } static android_LogPriority convert_to_android_(spdlog::level level) { switch (level) { - case spdlog::level::trace: - return ANDROID_LOG_VERBOSE; - case spdlog::level::debug: - return ANDROID_LOG_DEBUG; - case spdlog::level::info: - return ANDROID_LOG_INFO; - case spdlog::level::warn: - return ANDROID_LOG_WARN; - case spdlog::level::err: - return ANDROID_LOG_ERROR; - case spdlog::level::critical: - return ANDROID_LOG_FATAL; - default: - return ANDROID_LOG_DEFAULT; + case spdlog::level::trace: + return ANDROID_LOG_VERBOSE; + case spdlog::level::debug: + return ANDROID_LOG_DEBUG; + case spdlog::level::info: + return ANDROID_LOG_INFO; + case spdlog::level::warn: + return ANDROID_LOG_WARN; + case spdlog::level::err: + return ANDROID_LOG_ERROR; + case spdlog::level::critical: + return ANDROID_LOG_FATAL; + default: + return ANDROID_LOG_DEFAULT; } } @@ -116,7 +116,7 @@ using android_sink_buf_mt = android_sink; template using android_sink_buf_st = android_sink; -} // namespace sinks +} // namespace sinks // Create and register android syslog logger @@ -132,6 +132,6 @@ inline std::shared_ptr android_logger_st(const std::string &logger_name, return Factory::template create(logger_name, tag); } -} // namespace spdlog +} // namespace spdlog -#endif // __ANDROID__ +#endif // __ANDROID__ diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index c0dc567b..e7150806 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -107,5 +107,5 @@ using ansicolor_stdout_sink_st = ansicolor_stdout_sink; using ansicolor_stderr_sink_st = ansicolor_stderr_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h index fd17acd4..60a1e307 100644 --- a/include/spdlog/sinks/base_sink.h +++ b/include/spdlog/sinks/base_sink.h @@ -43,5 +43,5 @@ protected: virtual void set_pattern_(const std::string &pattern); virtual void set_formatter_(std::unique_ptr sink_formatter); }; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h index 75d369ab..f87df9b3 100644 --- a/include/spdlog/sinks/basic_file_sink.h +++ b/include/spdlog/sinks/basic_file_sink.h @@ -35,7 +35,7 @@ private: using basic_file_sink_mt = basic_file_sink; using basic_file_sink_st = basic_file_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -58,4 +58,4 @@ inline std::shared_ptr basic_logger_st(const std::string &logger_name, event_handlers); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/callback_sink.h b/include/spdlog/sinks/callback_sink.h index 419f84cd..71668ef2 100644 --- a/include/spdlog/sinks/callback_sink.h +++ b/include/spdlog/sinks/callback_sink.h @@ -36,7 +36,7 @@ private: using callback_sink_mt = callback_sink; using callback_sink_st = callback_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -53,4 +53,4 @@ inline std::shared_ptr callback_logger_st(const std::string &logger_name return Factory::template create(logger_name, callback); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/daily_file_sink.h b/include/spdlog/sinks/daily_file_sink.h index 54095b59..b25538d4 100644 --- a/include/spdlog/sinks/daily_file_sink.h +++ b/include/spdlog/sinks/daily_file_sink.h @@ -194,7 +194,7 @@ using daily_file_format_sink_mt = daily_file_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -212,14 +212,14 @@ inline std::shared_ptr daily_logger_mt(const std::string &logger_name, } template -inline std::shared_ptr -daily_logger_format_mt(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { +inline std::shared_ptr daily_logger_format_mt( + const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, hour, minute, truncate, max_files, event_handlers); } @@ -237,15 +237,15 @@ inline std::shared_ptr daily_logger_st(const std::string &logger_name, } template -inline std::shared_ptr -daily_logger_format_st(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { +inline std::shared_ptr daily_logger_format_st( + const std::string &logger_name, + const filename_t &filename, + int hour = 0, + int minute = 0, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { return Factory::template create( logger_name, filename, hour, minute, truncate, max_files, event_handlers); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 176a93ef..e759d2e7 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/include/spdlog/sinks/dist_sink.h @@ -77,5 +77,5 @@ protected: using dist_sink_mt = dist_sink; using dist_sink_st = dist_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/dup_filter_sink.h b/include/spdlog/sinks/dup_filter_sink.h index e35a8133..a9e71025 100644 --- a/include/spdlog/sinks/dup_filter_sink.h +++ b/include/spdlog/sinks/dup_filter_sink.h @@ -88,5 +88,5 @@ protected: using dup_filter_sink_mt = dup_filter_sink; using dup_filter_sink_st = dup_filter_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/hourly_file_sink.h b/include/spdlog/sinks/hourly_file_sink.h index 230d0d61..1f138925 100644 --- a/include/spdlog/sinks/hourly_file_sink.h +++ b/include/spdlog/sinks/hourly_file_sink.h @@ -164,7 +164,7 @@ private: using hourly_file_sink_mt = hourly_file_sink; using hourly_file_sink_st = hourly_file_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -188,4 +188,4 @@ inline std::shared_ptr hourly_logger_st(const std::string &logger_name, return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/kafka_sink.h b/include/spdlog/sinks/kafka_sink.h index d589449a..91e98786 100644 --- a/include/spdlog/sinks/kafka_sink.h +++ b/include/spdlog/sinks/kafka_sink.h @@ -90,7 +90,7 @@ private: using kafka_sink_mt = kafka_sink; using kafka_sink_st = kafka_sink; -} // namespace sinks +} // namespace sinks template inline std::shared_ptr kafka_logger_mt(const std::string &logger_name, @@ -105,15 +105,15 @@ inline std::shared_ptr kafka_logger_st(const std::string &logger_name, } template -inline std::shared_ptr -kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) { +inline std::shared_ptr kafka_logger_async_mt( + std::string logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } template -inline std::shared_ptr -kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config) { +inline std::shared_ptr kafka_logger_async_st( + std::string logger_name, spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/mongo_sink.h b/include/spdlog/sinks/mongo_sink.h index 966908ad..1210f1e0 100644 --- a/include/spdlog/sinks/mongo_sink.h +++ b/include/spdlog/sinks/mongo_sink.h @@ -83,26 +83,26 @@ private: using mongo_sink_mt = mongo_sink; using mongo_sink_st = mongo_sink; -} // namespace sinks +} // namespace sinks template -inline std::shared_ptr -mongo_logger_mt(const std::string &logger_name, - const std::string &db_name, - const std::string &collection_name, - const std::string &uri = "mongodb://localhost:27017") { +inline std::shared_ptr mongo_logger_mt( + const std::string &logger_name, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") { return Factory::template create(logger_name, db_name, collection_name, uri); } template -inline std::shared_ptr -mongo_logger_st(const std::string &logger_name, - const std::string &db_name, - const std::string &collection_name, - const std::string &uri = "mongodb://localhost:27017") { +inline std::shared_ptr mongo_logger_st( + const std::string &logger_name, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") { return Factory::template create(logger_name, db_name, collection_name, uri); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h index 65b2dc3f..3845674f 100644 --- a/include/spdlog/sinks/msvc_sink.h +++ b/include/spdlog/sinks/msvc_sink.h @@ -34,7 +34,7 @@ protected: } memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); - formatted.push_back('\0'); // add a null terminator for OutputDebugString + formatted.push_back('\0'); // add a null terminator for OutputDebugString OutputDebugStringA(formatted.data()); } @@ -49,7 +49,7 @@ using msvc_sink_st = msvc_sink; using windebug_sink_mt = msvc_sink_mt; using windebug_sink_st = msvc_sink_st; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog #endif diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h index 31d7b452..c51247fe 100644 --- a/include/spdlog/sinks/null_sink.h +++ b/include/spdlog/sinks/null_sink.h @@ -22,7 +22,7 @@ protected: using null_sink_mt = null_sink; using null_sink_st = null_sink; -} // namespace sinks +} // namespace sinks template inline std::shared_ptr null_logger_mt(const std::string &logger_name) { @@ -38,4 +38,4 @@ inline std::shared_ptr null_logger_st(const std::string &logger_name) { return null_logger; } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h index 46eadb5f..6af9dd09 100644 --- a/include/spdlog/sinks/ostream_sink.h +++ b/include/spdlog/sinks/ostream_sink.h @@ -39,5 +39,5 @@ protected: using ostream_sink_mt = ostream_sink; using ostream_sink_st = ostream_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/qt_sinks.h b/include/spdlog/sinks/qt_sinks.h index 8806c6e6..830d3727 100644 --- a/include/spdlog/sinks/qt_sinks.h +++ b/include/spdlog/sinks/qt_sinks.h @@ -167,13 +167,13 @@ protected: payload = QString::fromLatin1(str.data(), static_cast(str.size())); } - invoke_params params{max_lines_, // max lines - qt_text_edit_, // text edit to append to - std::move(payload), // text to append - default_color_, // default color - colors_.at(msg.log_level), // color to apply - color_range_start, // color range start - color_range_end}; // color range end + invoke_params params{max_lines_, // max lines + qt_text_edit_, // text edit to append to + std::move(payload), // text to append + default_color_, // default color + colors_.at(msg.log_level), // color to apply + color_range_start, // color range start + color_range_end}; // color range end QMetaObject::invokeMethod( qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); @@ -193,7 +193,7 @@ protected: while (document->blockCount() > params.max_lines) { cursor.select(QTextCursor::BlockUnderCursor); cursor.removeSelectedText(); - cursor.deleteChar(); // delete the newline after the block + cursor.deleteChar(); // delete the newline after the block } cursor.movePosition(QTextCursor::End); @@ -232,7 +232,7 @@ using qt_sink_mt = qt_sink; using qt_sink_st = qt_sink; using qt_color_sink_mt = qt_color_sink; using qt_color_sink_st = qt_color_sink; -} // namespace sinks +} // namespace sinks // // Factory functions @@ -269,14 +269,16 @@ inline std::shared_ptr qt_logger_st(const std::string &logger_name, } // log to QObject template -inline std::shared_ptr -qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { +inline std::shared_ptr qt_logger_mt(const std::string &logger_name, + QObject *qt_object, + const std::string &meta_method) { return Factory::template create(logger_name, qt_object, meta_method); } template -inline std::shared_ptr -qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { +inline std::shared_ptr qt_logger_st(const std::string &logger_name, + QObject *qt_object, + const std::string &meta_method) { return Factory::template create(logger_name, qt_object, meta_method); } @@ -299,4 +301,4 @@ inline std::shared_ptr qt_color_logger_st(const std::string &logger_name false, is_utf8); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/ringbuffer_sink.h b/include/spdlog/sinks/ringbuffer_sink.h index 2a6a13e4..9ce2fc9d 100644 --- a/include/spdlog/sinks/ringbuffer_sink.h +++ b/include/spdlog/sinks/ringbuffer_sink.h @@ -59,5 +59,5 @@ private: using ringbuffer_sink_mt = ringbuffer_sink; using ringbuffer_sink_st = ringbuffer_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/rotating_file_sink.h b/include/spdlog/sinks/rotating_file_sink.h index 4a51bf08..5ce477cc 100644 --- a/include/spdlog/sinks/rotating_file_sink.h +++ b/include/spdlog/sinks/rotating_file_sink.h @@ -55,7 +55,7 @@ private: using rotating_file_sink_mt = rotating_file_sink; using rotating_file_sink_st = rotating_file_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -82,4 +82,4 @@ inline std::shared_ptr rotating_logger_st(const std::string &logger_name return Factory::template create( logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index 7e9987d9..0bd37521 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -25,5 +25,5 @@ protected: atomic_level_t level_{level::trace}; }; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/stdout_color_sinks.h b/include/spdlog/sinks/stdout_color_sinks.h index 6baf8fb7..5b674119 100644 --- a/include/spdlog/sinks/stdout_color_sinks.h +++ b/include/spdlog/sinks/stdout_color_sinks.h @@ -25,7 +25,7 @@ using stdout_color_sink_st = ansicolor_stdout_sink_st; using stderr_color_sink_mt = ansicolor_stderr_sink_mt; using stderr_color_sink_st = ansicolor_stderr_sink_st; #endif -} // namespace sinks +} // namespace sinks // template instantations @@ -45,4 +45,4 @@ template std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index b19c96c7..64b487ab 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -41,7 +41,7 @@ protected: std::unique_ptr formatter_; #ifdef _WIN32 HANDLE handle_; -#endif // WIN32 +#endif // WIN32 }; template @@ -62,7 +62,7 @@ using stdout_sink_st = stdout_sink; using stderr_sink_mt = stderr_sink; using stderr_sink_st = stderr_sink; -} // namespace sinks +} // namespace sinks // factory methods template @@ -77,4 +77,4 @@ std::shared_ptr stderr_logger_mt(const std::string &logger_name); template std::shared_ptr stderr_logger_st(const std::string &logger_name); -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index 5119222c..87cac33a 100644 --- a/include/spdlog/sinks/syslog_sink.h +++ b/include/spdlog/sinks/syslog_sink.h @@ -18,7 +18,6 @@ namespace sinks { */ template class syslog_sink : public base_sink { - public: syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) : enable_formatting_{enable_formatting}, @@ -79,7 +78,7 @@ private: using syslog_sink_mt = syslog_sink; using syslog_sink_st = syslog_sink; -} // namespace sinks +} // namespace sinks // Create and register a syslog logger template @@ -101,4 +100,4 @@ inline std::shared_ptr syslog_logger_st(const std::string &logger_name, return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/systemd_sink.h b/include/spdlog/sinks/systemd_sink.h index aba29e79..17f36445 100644 --- a/include/spdlog/sinks/systemd_sink.h +++ b/include/spdlog/sinks/systemd_sink.h @@ -100,7 +100,7 @@ protected: using systemd_sink_mt = systemd_sink; using systemd_sink_st = systemd_sink; -} // namespace sinks +} // namespace sinks // Create and register a syslog logger template @@ -116,4 +116,4 @@ inline std::shared_ptr systemd_logger_st(const std::string &logger_name, bool enable_formatting = false) { return Factory::template create(logger_name, ident, enable_formatting); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/tcp_sink.h b/include/spdlog/sinks/tcp_sink.h index 8ce4ff05..25349645 100644 --- a/include/spdlog/sinks/tcp_sink.h +++ b/include/spdlog/sinks/tcp_sink.h @@ -31,7 +31,7 @@ namespace sinks { struct tcp_sink_config { std::string server_host; int server_port; - bool lazy_connect = false; // if true connect on first log call instead of on construction + bool lazy_connect = false; // if true connect on first log call instead of on construction tcp_sink_config(std::string host, int port) : server_host{std::move(host)}, @@ -71,5 +71,5 @@ protected: using tcp_sink_mt = tcp_sink; using tcp_sink_st = tcp_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/udp_sink.h b/include/spdlog/sinks/udp_sink.h index d2c5351d..4bff0fd2 100644 --- a/include/spdlog/sinks/udp_sink.h +++ b/include/spdlog/sinks/udp_sink.h @@ -55,7 +55,7 @@ protected: using udp_sink_mt = udp_sink; using udp_sink_st = udp_sink; -} // namespace sinks +} // namespace sinks // // factory functions @@ -66,4 +66,4 @@ inline std::shared_ptr udp_logger_mt(const std::string &logger_name, return Factory::template create(logger_name, skin_config); } -} // namespace spdlog +} // namespace spdlog diff --git a/include/spdlog/sinks/win_eventlog_sink.h b/include/spdlog/sinks/win_eventlog_sink.h index 5fa8b335..3507bf2c 100644 --- a/include/spdlog/sinks/win_eventlog_sink.h +++ b/include/spdlog/sinks/win_eventlog_sink.h @@ -131,7 +131,7 @@ public: ~process_token_t() { ::CloseHandle(token_handle_); } } current_process_token( - ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! + ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return // the token size @@ -156,30 +156,30 @@ public: struct eventlog { static WORD get_event_type(details::log_msg const &msg) { switch (msg.log_level) { - case level::trace: - case level::debug: - return EVENTLOG_SUCCESS; + case level::trace: + case level::debug: + return EVENTLOG_SUCCESS; - case level::info: - return EVENTLOG_INFORMATION_TYPE; + case level::info: + return EVENTLOG_INFORMATION_TYPE; - case spdlog::level::warn: - return EVENTLOG_WARNING_TYPE; + case spdlog::level::warn: + return EVENTLOG_WARNING_TYPE; - case level::err: - case level::critical: - case level::off: - return EVENTLOG_ERROR_TYPE; + case level::err: + case level::critical: + case level::off: + return EVENTLOG_ERROR_TYPE; - default: - return EVENTLOG_INFORMATION_TYPE; + default: + return EVENTLOG_INFORMATION_TYPE; } } static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.log_level; } }; -} // namespace internal +} // namespace internal /* * Windows Event Log sink @@ -238,15 +238,14 @@ public: } ~win_eventlog_sink() { - if (hEventLog_) - DeregisterEventSource(hEventLog_); + if (hEventLog_) DeregisterEventSource(hEventLog_); } }; -} // namespace win_eventlog +} // namespace win_eventlog using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink; using win_eventlog_sink_st = win_eventlog::win_eventlog_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index 4784fe0f..76fcaac0 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -74,5 +74,5 @@ using wincolor_stdout_sink_st = wincolor_stdout_sink using wincolor_stderr_sink_mt = wincolor_stderr_sink; using wincolor_stderr_sink_st = wincolor_stderr_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 40d46e3f..60dcf49a 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -251,7 +251,7 @@ inline void error(string_view_t msg) { log(level::err, msg); } inline void critical(string_view_t msg) { log(level::critical, msg); } #endif -} // namespace spdlog +} // namespace spdlog // // enable/disable log calls at compile time according to global level. @@ -328,4 +328,4 @@ inline void critical(string_view_t msg) { log(level::critical, msg); } #define SPDLOG_CRITICAL(...) (void)0 #endif -#endif // SPDLOG_H +#endif // SPDLOG_H diff --git a/include/spdlog/stopwatch.h b/include/spdlog/stopwatch.h index 3dc1693b..d19e591f 100644 --- a/include/spdlog/stopwatch.h +++ b/include/spdlog/stopwatch.h @@ -41,7 +41,7 @@ public: void reset() { start_tp_ = clock::now(); } }; -} // namespace spdlog +} // namespace spdlog // Support for fmt formatting (e.g. "{:012.9}" or just "{}") namespace @@ -59,4 +59,4 @@ struct formatter : formatter { return formatter::format(sw.elapsed().count(), ctx); } }; -} // namespace std +} // namespace std diff --git a/src/cfg/helpers.cpp b/src/cfg/helpers.cpp index 6e4ece25..0dfab508 100644 --- a/src/cfg/helpers.cpp +++ b/src/cfg/helpers.cpp @@ -83,7 +83,7 @@ void load_levels(const std::string &input) { if (level == level::off && level_name != "off") { continue; } - if (logger_name.empty()) // no logger name indicate global level + if (logger_name.empty()) // no logger name indicate global level { global_level_found = true; global_level = level; @@ -96,6 +96,6 @@ void load_levels(const std::string &input) { global_level_found ? &global_level : nullptr); } -} // namespace helpers -} // namespace cfg -} // namespace spdlog +} // namespace helpers +} // namespace cfg +} // namespace spdlog diff --git a/src/common.cpp b/src/common.cpp index b5f487c9..ea34e848 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -44,4 +44,4 @@ void throw_spdlog_ex(const std::string &msg, int last_errno) { void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } -} // namespace spdlog +} // namespace spdlog diff --git a/src/details/file_helper.cpp b/src/details/file_helper.cpp index a294b6b6..375953c7 100644 --- a/src/details/file_helper.cpp +++ b/src/details/file_helper.cpp @@ -139,5 +139,5 @@ std::tuple file_helper::split_by_extension(const filenam return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); } -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/details/log_msg.cpp b/src/details/log_msg.cpp index a16525ed..f12d8ec5 100644 --- a/src/details/log_msg.cpp +++ b/src/details/log_msg.cpp @@ -33,5 +33,5 @@ log_msg::log_msg(spdlog::source_loc loc, log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg) : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/details/log_msg_buffer.cpp b/src/details/log_msg_buffer.cpp index a82d33be..1ae77e96 100644 --- a/src/details/log_msg_buffer.cpp +++ b/src/details/log_msg_buffer.cpp @@ -46,5 +46,5 @@ void log_msg_buffer::update_string_views() { payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; } -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/details/os.cpp b/src/details/os.cpp index 83b1e1d5..b25f35f3 100644 --- a/src/details/os.cpp +++ b/src/details/os.cpp @@ -17,9 +17,9 @@ #ifdef _WIN32 #include - #include // for FlushFileBuffers - #include // for _get_osfhandle, _isatty, _fileno - #include // for _get_pid + #include // for FlushFileBuffers + #include // for _get_osfhandle, _isatty, _fileno + #include // for _get_pid #ifdef __MINGW32__ #include @@ -30,37 +30,37 @@ #include #endif - #include // for _mkdir/_wmkdir + #include // for _mkdir/_wmkdir -#else // unix +#else // unix #include #include #ifdef __linux__ - #include //Use gettid() syscall under linux to get thread id + #include //Use gettid() syscall under linux to get thread id #elif defined(_AIX) - #include // for pthread_getthrds_np + #include // for pthread_getthrds_np #elif defined(__DragonFly__) || defined(__FreeBSD__) - #include // for pthread_getthreadid_np + #include // for pthread_getthreadid_np #elif defined(__NetBSD__) - #include // for _lwp_self + #include // for _lwp_self #elif defined(__sun) - #include // for thr_self + #include // for thr_self #endif -#endif // unix +#endif // unix #if defined __APPLE__ #include #endif -#ifndef __has_feature // Clang - feature checking macros. - #define __has_feature(x) 0 // Compatibility with non-clang compilers. +#ifndef __has_feature // Clang - feature checking macros. + #define __has_feature(x) 0 // Compatibility with non-clang compilers. #endif namespace spdlog { @@ -68,7 +68,6 @@ namespace details { namespace os { spdlog::log_clock::time_point now() noexcept { - #if defined __linux__ && defined SPDLOG_CLOCK_COARSE timespec ts; ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); @@ -81,7 +80,6 @@ spdlog::log_clock::time_point now() noexcept { #endif } std::tm localtime(const std::time_t &time_tt) noexcept { - #ifdef _WIN32 std::tm tm; ::localtime_s(&tm, &time_tt); @@ -98,7 +96,6 @@ std::tm localtime() noexcept { } std::tm gmtime(const std::time_t &time_tt) noexcept { - #ifdef _WIN32 std::tm tm; ::gmtime_s(&tm, &time_tt); @@ -131,7 +128,7 @@ bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) { } } #endif -#else // unix +#else // unix #if defined(SPDLOG_PREVENT_CHILD_FD) const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int fd = @@ -180,7 +177,7 @@ bool path_exists(const filename_t &filename) noexcept { auto attribs = ::GetFileAttributesA(filename.c_str()); #endif return attribs != INVALID_FILE_ATTRIBUTES; -#else // common linux/unix all have the stat system call +#else // common linux/unix all have the stat system call struct stat buffer; return (::stat(filename.c_str(), &buffer) == 0); #endif @@ -199,20 +196,20 @@ size_t filesize(FILE *f) { } #if defined(_WIN32) && !defined(__CYGWIN__) int fd = ::_fileno(f); - #if defined(_WIN64) // 64 bits + #if defined(_WIN64) // 64 bits __int64 ret = ::_filelengthi64(fd); if (ret >= 0) { return static_cast(ret); } - #else // windows 32 bits + #else // windows 32 bits long ret = ::_filelength(fd); if (ret >= 0) { return static_cast(ret); } #endif -#else // unix +#else // unix // OpenBSD and AIX doesn't compile with :: before the fileno(..) #if defined(__OpenBSD__) || defined(_AIX) int fd = fileno(f); @@ -226,7 +223,7 @@ size_t filesize(FILE *f) { if (::fstat64(fd, &st) == 0) { return static_cast(st.st_size); } - #else // other unix or linux 32 bits or cygwin + #else // other unix or linux 32 bits or cygwin struct stat st; if (::fstat(fd, &st) == 0) { return static_cast(st.st_size); @@ -234,7 +231,7 @@ size_t filesize(FILE *f) { #endif #endif throw_spdlog_ex("Failed getting file size from fd", errno); - return 0; // will not be reached. + return 0; // will not be reached. } #ifdef _MSC_VER @@ -243,7 +240,6 @@ size_t filesize(FILE *f) { // Return utc offset in minutes or throw spdlog_ex on failure int utc_minutes_offset(const std::tm &tm) { - #ifdef _WIN32 #if _WIN32_WINNT < _WIN32_WINNT_WS08 TIME_ZONE_INFORMATION tzinfo; @@ -252,8 +248,7 @@ int utc_minutes_offset(const std::tm &tm) { DYNAMIC_TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); #endif - if (rv == TIME_ZONE_ID_INVALID) - throw_spdlog_ex("Failed getting timezone info. ", errno); + if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); int offset = -tzinfo.Bias; if (tm.tm_isdst) { @@ -345,7 +340,7 @@ size_t _thread_id() noexcept { pthread_threadid_np(nullptr, &tid); #endif return static_cast(tid); -#else // Default to standard C++11 (other Unix) +#else // Default to standard C++11 (other Unix) return static_cast(std::hash()(std::this_thread::get_id())); #endif } @@ -379,7 +374,6 @@ std::string filename_to_str(const filename_t &filename) { return filename; } #endif int pid() noexcept { - #ifdef _WIN32 return static_cast(::GetCurrentProcessId()); #else @@ -421,7 +415,6 @@ bool is_color_terminal() noexcept { // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ bool in_terminal(FILE *file) noexcept { - #ifdef _WIN32 return ::_isatty(_fileno(file)) != 0; #else @@ -490,7 +483,7 @@ void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) { throw_spdlog_ex( fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); } -#endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) +#endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) // return true on success static bool mkdir_(const filename_t &path) { @@ -527,7 +520,7 @@ bool create_dir(const filename_t &path) { auto subdir = path.substr(0, token_pos); if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { - return false; // return error if failed creating dir + return false; // return error if failed creating dir } search_offset = token_pos + 1; } while (search_offset < path.size()); @@ -546,17 +539,16 @@ filename_t dir_name(const filename_t &path) { } std::string getenv(const char *field) { - #if defined(_MSC_VER) #if defined(__cplusplus_winrt) - return std::string{}; // not supported under uwp + return std::string{}; // not supported under uwp #else size_t len = 0; char buf[128]; bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; return ok ? buf : std::string{}; #endif -#else // revert to getenv +#else // revert to getenv char *buf = ::getenv(field); return buf ? buf : std::string{}; #endif @@ -572,6 +564,6 @@ bool fsync(FILE *fp) { #endif } -} // namespace os -} // namespace details -} // namespace spdlog +} // namespace os +} // namespace details +} // namespace spdlog diff --git a/src/details/periodic_worker.cpp b/src/details/periodic_worker.cpp index 0b91541f..a00362f3 100644 --- a/src/details/periodic_worker.cpp +++ b/src/details/periodic_worker.cpp @@ -18,5 +18,5 @@ periodic_worker::~periodic_worker() { } } -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/details/registry.cpp b/src/details/registry.cpp index b9480192..ca950929 100644 --- a/src/details/registry.cpp +++ b/src/details/registry.cpp @@ -15,7 +15,7 @@ #else #include #endif -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER +#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #include #include @@ -28,7 +28,6 @@ namespace details { registry::registry() : formatter_(new pattern_formatter()) { - #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). #ifdef _WIN32 @@ -41,7 +40,7 @@ registry::registry() default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); loggers_[default_logger_name] = default_logger_; -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER +#endif // SPDLOG_DISABLE_DEFAULT_LOGGER } registry::~registry() = default; @@ -236,5 +235,5 @@ void registry::register_logger_(std::shared_ptr new_logger) { loggers_[logger_name] = std::move(new_logger); } -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/details/thread_pool.cpp b/src/details/thread_pool.cpp index 114171ff..ae8652e7 100644 --- a/src/details/thread_pool.cpp +++ b/src/details/thread_pool.cpp @@ -14,8 +14,9 @@ thread_pool::thread_pool(size_t q_max_items, std::function on_thread_stop) : q_(q_max_items) { if (threads_n == 0 || threads_n > 1000) { - throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " - "range is 1-1000)"); + throw_spdlog_ex( + "spdlog::thread_pool(): invalid threads_n param (valid " + "range is 1-1000)"); } for (size_t i = 0; i < threads_n; i++) { threads_.emplace_back([this, on_thread_start, on_thread_stop] { @@ -94,26 +95,26 @@ bool thread_pool::process_next_msg_() { q_.dequeue(incoming_async_msg); switch (incoming_async_msg.msg_type) { - case async_msg_type::log: { - incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); - return true; - } - case async_msg_type::flush: { - incoming_async_msg.worker_ptr->backend_flush_(); - return true; - } + case async_msg_type::log: { + incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); + return true; + } + case async_msg_type::flush: { + incoming_async_msg.worker_ptr->backend_flush_(); + return true; + } - case async_msg_type::terminate: { - return false; - } + case async_msg_type::terminate: { + return false; + } - default: { - assert(false); - } + default: { + assert(false); + } } return true; } -} // namespace details -} // namespace spdlog +} // namespace details +} // namespace spdlog diff --git a/src/fmt/bundled_fmtlib_format.cpp b/src/fmt/bundled_fmtlib_format.cpp index 4d5700ef..96d75d49 100644 --- a/src/fmt/bundled_fmtlib_format.cpp +++ b/src/fmt/bundled_fmtlib_format.cpp @@ -23,8 +23,10 @@ template FMT_API auto decimal_point_impl(locale_ref) -> char; template FMT_API void buffer::append(const char *, const char *); -template FMT_API void -vformat_to(buffer &, string_view, typename vformat_args<>::type, locale_ref); +template FMT_API void vformat_to(buffer &, + string_view, + typename vformat_args<>::type, + locale_ref); // Explicit instantiations for wchar_t. @@ -33,7 +35,7 @@ template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; template FMT_API void buffer::append(const wchar_t *, const wchar_t *); -} // namespace detail +} // namespace detail FMT_END_NAMESPACE -#endif // !SPDLOG_FMT_EXTERNAL +#endif // !SPDLOG_FMT_EXTERNAL diff --git a/src/logger.cpp b/src/logger.cpp index 58773cdb..a08895cc 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -38,7 +38,7 @@ void logger::set_formatter(std::unique_ptr f) { if (std::next(it) == sinks_.end()) { // last element - we can be move it. (*it)->set_formatter(std::move(f)); - break; // to prevent clang-tidy warning + break; // to prevent clang-tidy warning } else { (*it)->set_formatter(f->clone()); } @@ -102,7 +102,7 @@ void logger::err_handler_(const std::string &msg) { auto tm_time = details::os::localtime(system_clock::to_time_t(now)); char date_buf[64]; std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); -#if defined(USING_R) && defined(R_R_H) // if in R environment +#if defined(USING_R) && defined(R_R_H) // if in R environment REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); #else @@ -111,4 +111,4 @@ void logger::err_handler_(const std::string &msg) { #endif } } -} // namespace spdlog +} // namespace spdlog diff --git a/src/pattern_formatter.cpp b/src/pattern_formatter.cpp index bd31b4f8..56f82166 100644 --- a/src/pattern_formatter.cpp +++ b/src/pattern_formatter.cpp @@ -41,7 +41,7 @@ public: auto half_pad = remaining_pad_ / 2; auto reminder = remaining_pad_ & 1; pad_it(half_pad); - remaining_pad_ = half_pad + reminder; // for the right side + remaining_pad_ = half_pad + reminder; // for the right side } } @@ -515,9 +515,9 @@ public: dest.push_back('+'); } - fmt_helper::pad2(total_minutes / 60, dest); // hours + fmt_helper::pad2(total_minutes / 60, dest); // hours dest.push_back(':'); - fmt_helper::pad2(total_minutes % 60, dest); // minutes + fmt_helper::pad2(total_minutes % 60, dest); // minutes } private: @@ -679,8 +679,8 @@ public: #ifdef _MSC_VER #pragma warning(push) - #pragma warning(disable : 4127) // consider using 'if constexpr' instead -#endif // _MSC_VER + #pragma warning(disable : 4127) // consider using 'if constexpr' instead +#endif // _MSC_VER static const char *basename(const char *filename) { // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr // the branch will be elided by optimizations @@ -698,7 +698,7 @@ public: } #ifdef _MSC_VER #pragma warning(pop) -#endif // _MSC_VER +#endif // _MSC_VER void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { if (msg.source.empty()) { @@ -857,7 +857,7 @@ private: memory_buf_t cached_datetime_; }; -} // namespace details +} // namespace details pattern_formatter::pattern_formatter(std::string pattern, pattern_time_type time_type, @@ -944,227 +944,231 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { // process built-in flags switch (flag) { - case ('+'): // default formatter - formatters_.push_back(std::make_unique(padding)); - need_localtime_ = true; - break; + case ('+'): // default formatter + formatters_.push_back(std::make_unique(padding)); + need_localtime_ = true; + break; - case 'n': // logger name - formatters_.push_back(std::make_unique>(padding)); - break; + case 'n': // logger name + formatters_.push_back(std::make_unique>(padding)); + break; - case 'l': // level - formatters_.push_back(std::make_unique>(padding)); - break; + case 'l': // level + formatters_.push_back(std::make_unique>(padding)); + break; - case 'L': // short level - formatters_.push_back(std::make_unique>(padding)); - break; + case 'L': // short level + formatters_.push_back( + std::make_unique>(padding)); + break; - case ('t'): // thread id - formatters_.push_back(std::make_unique>(padding)); - break; + case ('t'): // thread id + formatters_.push_back(std::make_unique>(padding)); + break; - case ('v'): // the message text - formatters_.push_back(std::make_unique>(padding)); - break; + case ('v'): // the message text + formatters_.push_back(std::make_unique>(padding)); + break; - case ('a'): // weekday - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('a'): // weekday + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('A'): // short weekday - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('A'): // short weekday + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('b'): - case ('h'): // month - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('b'): + case ('h'): // month + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('B'): // short month - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('B'): // short month + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('c'): // datetime - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('c'): // datetime + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('C'): // year 2 digits - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('C'): // year 2 digits + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('Y'): // year 4 digits - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('Y'): // year 4 digits + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('D'): - case ('x'): // datetime MM/DD/YY - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('D'): + case ('x'): // datetime MM/DD/YY + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('m'): // month 1-12 - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('m'): // month 1-12 + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('d'): // day of month 1-31 - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('d'): // day of month 1-31 + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('H'): // hours 24 - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('H'): // hours 24 + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('I'): // hours 12 - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('I'): // hours 12 + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('M'): // minutes - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('M'): // minutes + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('S'): // seconds - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('S'): // seconds + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('e'): // milliseconds - formatters_.push_back(std::make_unique>(padding)); - break; + case ('e'): // milliseconds + formatters_.push_back(std::make_unique>(padding)); + break; - case ('f'): // microseconds - formatters_.push_back(std::make_unique>(padding)); - break; + case ('f'): // microseconds + formatters_.push_back(std::make_unique>(padding)); + break; - case ('F'): // nanoseconds - formatters_.push_back(std::make_unique>(padding)); - break; + case ('F'): // nanoseconds + formatters_.push_back(std::make_unique>(padding)); + break; - case ('E'): // seconds since epoch - formatters_.push_back(std::make_unique>(padding)); - break; + case ('E'): // seconds since epoch + formatters_.push_back(std::make_unique>(padding)); + break; - case ('p'): // am/pm - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('p'): // am/pm + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('r'): // 12 hour clock 02:55:02 pm - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('r'): // 12 hour clock 02:55:02 pm + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('R'): // 24-hour HH:MM time - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('R'): // 24-hour HH:MM time + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('T'): - case ('X'): // ISO 8601 time format (HH:MM:SS) - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('T'): + case ('X'): // ISO 8601 time format (HH:MM:SS) + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('z'): // timezone - formatters_.push_back(std::make_unique>(padding)); - need_localtime_ = true; - break; + case ('z'): // timezone + formatters_.push_back(std::make_unique>(padding)); + need_localtime_ = true; + break; - case ('P'): // pid - formatters_.push_back(std::make_unique>(padding)); - break; + case ('P'): // pid + formatters_.push_back(std::make_unique>(padding)); + break; - case ('^'): // color range start - formatters_.push_back(std::make_unique(padding)); - break; + case ('^'): // color range start + formatters_.push_back(std::make_unique(padding)); + break; - case ('$'): // color range end - formatters_.push_back(std::make_unique(padding)); - break; + case ('$'): // color range end + formatters_.push_back(std::make_unique(padding)); + break; - case ('@'): // source location (filename:filenumber) - formatters_.push_back( - std::make_unique>(padding)); - break; + case ('@'): // source location (filename:filenumber) + formatters_.push_back( + std::make_unique>(padding)); + break; - case ('s'): // short source filename - without directory name - formatters_.push_back(std::make_unique>(padding)); - break; + case ('s'): // short source filename - without directory name + formatters_.push_back( + std::make_unique>(padding)); + break; - case ('g'): // full source filename - formatters_.push_back( - std::make_unique>(padding)); - break; + case ('g'): // full source filename + formatters_.push_back( + std::make_unique>(padding)); + break; - case ('#'): // source line number - formatters_.push_back(std::make_unique>(padding)); - break; + case ('#'): // source line number + formatters_.push_back( + std::make_unique>(padding)); + break; - case ('!'): // source funcname - formatters_.push_back( - std::make_unique>(padding)); - break; - - case ('%'): // % char - formatters_.push_back(std::make_unique('%')); - break; - - case ('u'): // elapsed time since last log message in nanos - formatters_.push_back( - std::make_unique>( - padding)); - break; - - case ('i'): // elapsed time since last log message in micros - formatters_.push_back( - std::make_unique>( - padding)); - break; - - case ('o'): // elapsed time since last log message in millis - formatters_.push_back( - std::make_unique>( - padding)); - break; - - case ('O'): // elapsed time since last log message in seconds - formatters_.push_back( - std::make_unique>(padding)); - break; - - default: // Unknown flag appears as is - auto unknown_flag = std::make_unique(); - - if (!padding.truncate_) { - unknown_flag->add_ch('%'); - unknown_flag->add_ch(flag); - formatters_.push_back((std::move(unknown_flag))); - } - // fix issue #1617 (prev char was '!' and should have been treated as funcname flag instead - // of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some message" - // spdlog::set_pattern("[%3!!] %v") => "[mai] some message" - else { - padding.truncate_ = false; + case ('!'): // source funcname formatters_.push_back( std::make_unique>(padding)); - unknown_flag->add_ch(flag); - formatters_.push_back((std::move(unknown_flag))); - } + break; - break; + case ('%'): // % char + formatters_.push_back(std::make_unique('%')); + break; + + case ('u'): // elapsed time since last log message in nanos + formatters_.push_back( + std::make_unique>( + padding)); + break; + + case ('i'): // elapsed time since last log message in micros + formatters_.push_back( + std::make_unique>( + padding)); + break; + + case ('o'): // elapsed time since last log message in millis + formatters_.push_back( + std::make_unique>( + padding)); + break; + + case ('O'): // elapsed time since last log message in seconds + formatters_.push_back( + std::make_unique>( + padding)); + break; + + default: // Unknown flag appears as is + auto unknown_flag = std::make_unique(); + + if (!padding.truncate_) { + unknown_flag->add_ch('%'); + unknown_flag->add_ch(flag); + formatters_.push_back((std::move(unknown_flag))); + } + // fix issue #1617 (prev char was '!' and should have been treated as funcname flag + // instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some + // message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message" + else { + padding.truncate_ = false; + formatters_.push_back( + std::make_unique>(padding)); + unknown_flag->add_ch(flag); + formatters_.push_back((std::move(unknown_flag))); + } + + break; } } @@ -1182,21 +1186,21 @@ details::padding_info pattern_formatter::handle_padspec_(std::string::const_iter padding_info::pad_side side; switch (*it) { - case '-': - side = padding_info::pad_side::right; - ++it; - break; - case '=': - side = padding_info::pad_side::center; - ++it; - break; - default: - side = details::padding_info::pad_side::left; - break; + case '-': + side = padding_info::pad_side::right; + ++it; + break; + case '=': + side = padding_info::pad_side::center; + ++it; + break; + default: + side = details::padding_info::pad_side::left; + break; } if (it == end || !std::isdigit(static_cast(*it))) { - return padding_info{}; // no padding if no digit found here + return padding_info{}; // no padding if no digit found here } auto width = static_cast(*it) - '0'; @@ -1222,7 +1226,7 @@ void pattern_formatter::compile_pattern_(const std::string &pattern) { formatters_.clear(); for (auto it = pattern.begin(); it != end; ++it) { if (*it == '%') { - if (user_chars) // append user chars found so far + if (user_chars) // append user chars found so far { formatters_.push_back(std::move(user_chars)); } @@ -1238,7 +1242,7 @@ void pattern_formatter::compile_pattern_(const std::string &pattern) { } else { break; } - } else // chars not following the % sign should be displayed as is + } else // chars not following the % sign should be displayed as is { if (!user_chars) { user_chars = std::make_unique(); @@ -1246,9 +1250,9 @@ void pattern_formatter::compile_pattern_(const std::string &pattern) { user_chars->add_ch(*it); } } - if (user_chars) // append raw chars found so far + if (user_chars) // append raw chars found so far { formatters_.push_back(std::move(user_chars)); } } -} // namespace spdlog +} // namespace spdlog diff --git a/src/sinks/ansicolor_sink.cpp b/src/sinks/ansicolor_sink.cpp index 0bace042..32df8351 100644 --- a/src/sinks/ansicolor_sink.cpp +++ b/src/sinks/ansicolor_sink.cpp @@ -50,7 +50,7 @@ void ansicolor_sink::log(const details::log_msg &msg) { 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()); } @@ -84,18 +84,18 @@ bool ansicolor_sink::should_color() { template void ansicolor_sink::set_color_mode(color_mode mode) { switch (mode) { - case color_mode::always: - should_do_colors_ = true; - return; - case color_mode::automatic: - should_do_colors_ = - details::os::in_terminal(target_file_) && details::os::is_color_terminal(); - return; - case color_mode::never: - should_do_colors_ = false; - return; - default: - should_do_colors_ = false; + case color_mode::always: + should_do_colors_ = true; + return; + case color_mode::automatic: + should_do_colors_ = + details::os::in_terminal(target_file_) && details::os::is_color_terminal(); + return; + case color_mode::never: + should_do_colors_ = false; + return; + default: + should_do_colors_ = false; } } @@ -126,8 +126,8 @@ template ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) : ansicolor_sink(stderr, mode) {} -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog // template instantiations template SPDLOG_API class spdlog::sinks::ansicolor_stdout_sink; diff --git a/src/sinks/basic_file_sink.cpp b/src/sinks/basic_file_sink.cpp index 40c627b7..8fb00a41 100644 --- a/src/sinks/basic_file_sink.cpp +++ b/src/sinks/basic_file_sink.cpp @@ -34,8 +34,8 @@ void basic_file_sink::flush_() { file_helper_.flush(); } -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog // template instantiations template class SPDLOG_API spdlog::sinks::basic_file_sink; diff --git a/src/sinks/rotating_file_sink.cpp b/src/sinks/rotating_file_sink.cpp index 366174f3..b52077ff 100644 --- a/src/sinks/rotating_file_sink.cpp +++ b/src/sinks/rotating_file_sink.cpp @@ -34,7 +34,7 @@ rotating_file_sink::rotating_file_sink(filename_t base_filename, throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); } file_helper_.open(calc_filename(base_filename_, 0)); - current_size_ = file_helper_.size(); // expensive. called only once + current_size_ = file_helper_.size(); // expensive. called only once if (rotate_on_open && current_size_ > 0) { rotate_(); current_size_ = 0; @@ -106,11 +106,12 @@ void rotating_file_sink::rotate_() { 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)) { - file_helper_.reopen( - true); // truncate the log file anyway to prevent it to grow beyond its limit! + file_helper_.reopen(true); // truncate the log file anyway to prevent it + // to grow beyond its limit! current_size_ = 0; throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), @@ -131,8 +132,8 @@ bool rotating_file_sink::rename_file_(const filename_t &src_filename, return details::os::rename(src_filename, target_filename) == 0; } -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog // template instantiations template class SPDLOG_API spdlog::sinks::rotating_file_sink; diff --git a/src/sinks/stdout_color_sinks.cpp b/src/sinks/stdout_color_sinks.cpp index 69920bc6..54bb8e3b 100644 --- a/src/sinks/stdout_color_sinks.cpp +++ b/src/sinks/stdout_color_sinks.cpp @@ -28,7 +28,7 @@ template std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -} // namespace spdlog +} // namespace spdlog // template instantiations template SPDLOG_API std::shared_ptr @@ -47,14 +47,14 @@ template SPDLOG_API std::shared_ptr spdlog::stderr_color_st(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stdout_color_mt(const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr spdlog::stdout_color_mt( + const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stdout_color_st(const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr spdlog::stdout_color_st( + const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stderr_color_mt(const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr spdlog::stderr_color_mt( + const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stderr_color_st(const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr spdlog::stderr_color_st( + const std::string &logger_name, color_mode mode); diff --git a/src/sinks/stdout_sinks.cpp b/src/sinks/stdout_sinks.cpp index 97e9db63..08169c31 100644 --- a/src/sinks/stdout_sinks.cpp +++ b/src/sinks/stdout_sinks.cpp @@ -10,13 +10,13 @@ // so instead we use ::FileWrite #include - #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp - #include // WriteFile (..) + #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp + #include // WriteFile (..) #endif - #include // _get_osfhandle(..) - #include // _fileno(..) -#endif // WIN32 + #include // _get_osfhandle(..) + #include // _fileno(..) +#endif // WIN32 namespace spdlog { @@ -38,7 +38,7 @@ stdout_sink_base::stdout_sink_base(FILE *file) if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); } -#endif // WIN32 +#endif // WIN32 } template @@ -62,8 +62,8 @@ void stdout_sink_base::log(const details::log_msg &msg) { memory_buf_t formatted; formatter_->format(msg, formatted); ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); -#endif // WIN32 - ::fflush(file_); // flush every line to terminal +#endif // WIN32 + ::fflush(file_); // flush every line to terminal } template @@ -95,7 +95,7 @@ template stderr_sink::stderr_sink() : stdout_sink_base(stderr) {} -} // namespace sinks +} // namespace sinks // factory methods template @@ -117,7 +117,7 @@ template std::shared_ptr stderr_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } -} // namespace spdlog +} // namespace spdlog // template instantiations for stdout/stderr loggers #include @@ -141,11 +141,11 @@ spdlog::stderr_logger_mt(const std::string &logger_ template SPDLOG_API std::shared_ptr spdlog::stderr_logger_st(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stdout_logger_mt(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stdout_logger_st(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stderr_logger_mt(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stderr_logger_st(const std::string &logger_name); +template SPDLOG_API std::shared_ptr spdlog::stdout_logger_mt( + const std::string &logger_name); +template SPDLOG_API std::shared_ptr spdlog::stdout_logger_st( + const std::string &logger_name); +template SPDLOG_API std::shared_ptr spdlog::stderr_logger_mt( + const std::string &logger_name); +template SPDLOG_API std::shared_ptr spdlog::stderr_logger_st( + const std::string &logger_name); diff --git a/src/sinks/wincolor_sink.cpp b/src/sinks/wincolor_sink.cpp index f1e71606..21d36461 100644 --- a/src/sinks/wincolor_sink.cpp +++ b/src/sinks/wincolor_sink.cpp @@ -19,15 +19,15 @@ wincolor_sink::wincolor_sink(void *out_handle, color_mode mode) set_color_mode_impl(mode); // set level colors colors_.at(level_to_number(level::trace)) = - FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white - colors_.at(level_to_number(level::debug)) = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan - colors_.at(level_to_number(level::info)) = FOREGROUND_GREEN; // green + FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white + colors_.at(level_to_number(level::debug)) = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan + colors_.at(level_to_number(level::info)) = FOREGROUND_GREEN; // green colors_.at(level_to_number(level::warn)) = - FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow - colors_.at(level_to_number(level::err)) = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red + FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow + colors_.at(level_to_number(level::err)) = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red colors_.at(level_to_number(level::critical)) = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | - FOREGROUND_INTENSITY; // intense white on red background + FOREGROUND_INTENSITY; // intense white on red background colors_.at(level_to_number(level::off)) = 0; } @@ -64,7 +64,7 @@ void wincolor_sink::log(const details::log_msg &msg) { // reset to orig colors ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs); print_range_(formatted, msg.color_range_end, formatted.size()); - } else // print without colors if color range is invalid (or color is disabled) + } else // print without colors if color range is invalid (or color is disabled) { write_to_file_(formatted); } @@ -119,7 +119,7 @@ std::uint16_t wincolor_sink::set_foreground_color_(std::uint16_t a auto ignored = ::SetConsoleTextAttribute(static_cast(out_handle_), static_cast(new_attribs)); (void)(ignored); - return static_cast(orig_buffer_info.wAttributes); // return orig attribs + return static_cast(orig_buffer_info.wAttributes); // return orig attribs } // print a range of formatted message to console @@ -153,8 +153,8 @@ wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) template wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog // template instantiations template class SPDLOG_API spdlog::sinks::wincolor_sink; @@ -164,4 +164,4 @@ template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; -#endif // _WIN32 +#endif // _WIN32 diff --git a/src/spdlog.cpp b/src/spdlog.cpp index ef6fde1f..912d2393 100644 --- a/src/spdlog.cpp +++ b/src/spdlog.cpp @@ -68,4 +68,4 @@ void apply_logger_env_levels(std::shared_ptr logger) { details::registry::instance().apply_logger_env_levels(std::move(logger)); } -} // namespace spdlog +} // namespace spdlog diff --git a/tests/includes.h b/tests/includes.h index 84e8bf91..8514d642 100644 --- a/tests/includes.h +++ b/tests/includes.h @@ -2,7 +2,7 @@ #if defined(__GNUC__) && __GNUC__ == 12 #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 + #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 #endif #include #if defined(__GNUC__) && __GNUC__ == 12 diff --git a/tests/main.cpp b/tests/main.cpp index fd562ad3..a4a4ff15 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -1,6 +1,6 @@ #if defined(__GNUC__) && __GNUC__ == 12 #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 + #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 #endif #include diff --git a/tests/test_async.cpp b/tests/test_async.cpp index 44d34ebe..76fdd7c6 100644 --- a/tests/test_async.cpp +++ b/tests/test_async.cpp @@ -94,7 +94,6 @@ TEST_CASE("flush", "[async]") { } TEST_CASE("async periodic flush", "[async]") { - auto logger = spdlog::create_async("as"); auto test_sink = std::static_pointer_cast(logger->sinks()[0]); diff --git a/tests/test_circular_q.cpp b/tests/test_circular_q.cpp index 6abcc974..84dac982 100644 --- a/tests/test_circular_q.cpp +++ b/tests/test_circular_q.cpp @@ -23,7 +23,7 @@ TEST_CASE("test_rolling", "[circular_q]") { for (size_t i = 0; i < q_size + 2; i++) { auto val = i; - q.push_back(std::move(val)); // arg to push_back must be r value + q.push_back(std::move(val)); // arg to push_back must be r value } REQUIRE(q.size() == q_size); @@ -49,7 +49,7 @@ TEST_CASE("test_rolling", "[circular_q]") { TEST_CASE("test_empty", "[circular_q]") { q_type q1(0); REQUIRE(q1.empty()); - REQUIRE(q1.full()); // q with capacity 0 is considered full + REQUIRE(q1.full()); // q with capacity 0 is considered full q1.push_back(1); REQUIRE(q1.empty()); diff --git a/tests/test_create_dir.cpp b/tests/test_create_dir.cpp index b53bebf1..f88825b0 100644 --- a/tests/test_create_dir.cpp +++ b/tests/test_create_dir.cpp @@ -19,7 +19,7 @@ TEST_CASE("create_dir", "[create_dir]") { REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), - SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing + SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"), SPDLOG_FILENAME_T("test_logs/dir1/dir2"))); REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"), diff --git a/tests/test_daily_logger.cpp b/tests/test_daily_logger.cpp index 138e6120..fe4783cb 100644 --- a/tests/test_daily_logger.cpp +++ b/tests/test_daily_logger.cpp @@ -37,7 +37,6 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") { auto logger = spdlog::create("logger", basename, 0, 0); for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); } logger->flush(); diff --git a/tests/test_dup_filter.cpp b/tests/test_dup_filter.cpp index 22623c2e..78e22be3 100644 --- a/tests/test_dup_filter.cpp +++ b/tests/test_dup_filter.cpp @@ -78,6 +78,6 @@ TEST_CASE("dup_filter_test5", "[dup_filter_sink]") { dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"}); REQUIRE(test_sink->msg_counter() == - 3); // skip 2 messages but log the "skipped.." message before message2 + 3); // skip 2 messages but log the "skipped.." message before message2 REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages.."); } diff --git a/tests/test_errors.cpp b/tests/test_errors.cpp index 35f12cb9..ccb447f8 100644 --- a/tests/test_errors.cpp +++ b/tests/test_errors.cpp @@ -19,7 +19,7 @@ protected: }; struct custom_ex {}; -#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support runtime format strings +#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support runtime format strings TEST_CASE("default_error_handler", "[errors]") { prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); @@ -62,7 +62,7 @@ TEST_CASE("flush_error_handler", "[errors]") { REQUIRE_THROWS_AS(logger->flush(), custom_ex); } -#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support runtime format strings +#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support runtime format strings TEST_CASE("async_error_handler", "[errors]") { prepare_logdir(); std::string err_msg("log failed with some msg"); @@ -82,7 +82,7 @@ TEST_CASE("async_error_handler", "[errors]") { logger->info("Good message #1"); logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"); logger->info("Good message #2"); - spdlog::drop("logger"); // force logger to drain the queue and shutdown + spdlog::drop("logger"); // force logger to drain the queue and shutdown } spdlog::init_thread_pool(128, 1); require_message_count(SIMPLE_ASYNC_LOG, 2); @@ -100,12 +100,11 @@ TEST_CASE("async_error_handler2", "[errors]") { auto logger = spdlog::create_async("failed_logger"); logger->set_error_handler([=](const std::string &) { std::ofstream ofs("test_logs/custom_err2.txt"); - if (!ofs) - throw std::runtime_error("Failed open test_logs/custom_err2.txt"); + if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt"); ofs << err_msg; }); logger->info("Hello failure"); - spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown + spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown } spdlog::init_thread_pool(128, 1); diff --git a/tests/test_eventlog.cpp b/tests/test_eventlog.cpp index 45d7f58d..702eabea 100644 --- a/tests/test_eventlog.cpp +++ b/tests/test_eventlog.cpp @@ -72,4 +72,4 @@ TEST_CASE("eventlog", "[eventlog]") { "my critical message", EVENTLOG_ERROR_TYPE); } -#endif //_WIN32 +#endif //_WIN32 diff --git a/tests/test_file_logging.cpp b/tests/test_file_logging.cpp index 73c59599..ac378b5c 100644 --- a/tests/test_file_logging.cpp +++ b/tests/test_file_logging.cpp @@ -85,7 +85,6 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]") { require_message_count(ROTATING_LOG, 10); for (int i = 0; i < 1000; i++) { - logger->info("Test message {}", i); } diff --git a/tests/test_macros.cpp b/tests/test_macros.cpp index 37a2a916..132706f1 100644 --- a/tests/test_macros.cpp +++ b/tests/test_macros.cpp @@ -12,7 +12,6 @@ #define TEST_FILENAME "test_logs/simple_log" TEST_CASE("debug and trace w/o format string", "[macros]") { - prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); diff --git a/tests/test_misc.cpp b/tests/test_misc.cpp index dec4f650..0dc7abf6 100644 --- a/tests/test_misc.cpp +++ b/tests/test_misc.cpp @@ -3,7 +3,6 @@ template std::string log_info(const T &what, spdlog::level logger_level = spdlog::level::info) { - std::ostringstream oss; auto oss_sink = std::make_shared(oss); diff --git a/tests/test_mpmc_q.cpp b/tests/test_mpmc_q.cpp index 41b99a21..bc7a37d9 100644 --- a/tests/test_mpmc_q.cpp +++ b/tests/test_mpmc_q.cpp @@ -22,7 +22,6 @@ TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") { } TEST_CASE("dequeue-empty-wait", "[mpmc_blocking_q]") { - size_t q_size = 100; milliseconds wait_ms(250); milliseconds tolerance_wait(250); @@ -59,7 +58,6 @@ TEST_CASE("dequeue-full-wait", "[mpmc_blocking_q]") { } TEST_CASE("enqueue_nowait", "[mpmc_blocking_q]") { - size_t q_size = 1; spdlog::details::mpmc_blocking_queue q(q_size); milliseconds tolerance_wait(10); @@ -96,8 +94,8 @@ TEST_CASE("full_queue", "[mpmc_blocking_q]") { size_t q_size = 100; spdlog::details::mpmc_blocking_queue q(q_size); for (int i = 0; i < static_cast(q_size); i++) { - q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we - // std::move(i) instead + q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we + // std::move(i) instead } q.enqueue_nowait(123456); diff --git a/tests/test_ringbuffer_sink.cpp b/tests/test_ringbuffer_sink.cpp index 0e08de8a..6dd9e88a 100644 --- a/tests/test_ringbuffer_sink.cpp +++ b/tests/test_ringbuffer_sink.cpp @@ -53,7 +53,7 @@ TEST_CASE("test_empty", "[ringbuffer_sink]") { spdlog::logger l("logger", sink); sink->drain([&](std::string_view) { - REQUIRE_FALSE(true); // should not be called since the sink is empty + REQUIRE_FALSE(true); // should not be called since the sink is empty }); } @@ -67,6 +67,6 @@ TEST_CASE("test_empty_size", "[ringbuffer_sink]") { } sink->drain([&](std::string_view) { - REQUIRE_FALSE(true); // should not be called since the sink size is 0 + REQUIRE_FALSE(true); // should not be called since the sink size is 0 }); } \ No newline at end of file diff --git a/tests/test_sink.h b/tests/test_sink.h index 9f5a9394..529d86dd 100644 --- a/tests/test_sink.h +++ b/tests/test_sink.h @@ -65,5 +65,5 @@ protected: using test_sink_mt = test_sink; using test_sink_st = test_sink; -} // namespace sinks -} // namespace spdlog +} // namespace sinks +} // namespace spdlog diff --git a/tests/test_time_point.cpp b/tests/test_time_point.cpp index c409bb24..b7b1b232 100644 --- a/tests/test_time_point.cpp +++ b/tests/test_time_point.cpp @@ -8,7 +8,7 @@ TEST_CASE("time_point1", "[time_point log_msg]") { spdlog::source_loc source{}; std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()}; - test_sink->set_pattern("%T.%F"); // interested in the time_point + test_sink->set_pattern("%T.%F"); // interested in the time_point // all the following should have the same time test_sink->set_delay(std::chrono::milliseconds(10)); @@ -22,7 +22,7 @@ TEST_CASE("time_point1", "[time_point log_msg]") { logger.log(tp, source, spdlog::level::info, "formatted message"); logger.log(tp, source, spdlog::level::info, "formatted message"); logger.log(source, spdlog::level::info, - "formatted message"); // last line has different time_point + "formatted message"); // last line has different time_point // now the real test... that the times are the same. std::vector lines = test_sink->lines(); diff --git a/tests/utils.cpp b/tests/utils.cpp index cec29c42..1fa26175 100644 --- a/tests/utils.cpp +++ b/tests/utils.cpp @@ -35,8 +35,7 @@ std::size_t count_lines(const std::string &filename) { std::string line; size_t counter = 0; - while (std::getline(ifs, line)) - counter++; + while (std::getline(ifs, line)) counter++; return counter; } @@ -74,10 +73,9 @@ std::size_t count_files(const std::string &folder) { // Start iterating over the files in the folder directory. HANDLE hFind = ::FindFirstFileA((folder + "\\*").c_str(), &ffd); if (hFind != INVALID_HANDLE_VALUE) { - do // Managed to locate and create an handle to that folder. + do // Managed to locate and create an handle to that folder. { - if (ffd.cFileName[0] != '.') - counter++; + if (ffd.cFileName[0] != '.') counter++; } while (::FindNextFileA(hFind, &ffd) != 0); ::FindClose(hFind); } else { @@ -97,8 +95,7 @@ std::size_t count_files(const std::string &folder) { struct dirent *ep = nullptr; while ((ep = readdir(dp)) != nullptr) { - if (ep->d_name[0] != '.') - counter++; + if (ep->d_name[0] != '.') counter++; } (void)closedir(dp); return counter;