From 1a0bfc7a89f2d58e22605a4dc7e18a9a555b65aa Mon Sep 17 00:00:00 2001 From: gabime Date: Mon, 25 Sep 2023 02:44:07 +0300 Subject: [PATCH] clang format --- include/spdlog/async.h | 46 +- include/spdlog/async_logger-inl.h | 97 +-- include/spdlog/async_logger.h | 36 +- include/spdlog/cfg/argv.h | 14 +- include/spdlog/cfg/env.h | 8 +- include/spdlog/cfg/helpers-inl.h | 51 +- include/spdlog/cfg/helpers.h | 2 +- include/spdlog/common-inl.h | 40 +- include/spdlog/common.h | 314 ++++---- include/spdlog/details/backtracer-inl.h | 34 +- include/spdlog/details/backtracer.h | 9 +- include/spdlog/details/circular_q.h | 77 +- include/spdlog/details/console_globals.h | 14 +- include/spdlog/details/file_helper-inl.h | 89 +-- include/spdlog/details/file_helper.h | 5 +- include/spdlog/details/fmt_helper.h | 98 +-- include/spdlog/details/log_msg-inl.h | 37 +- include/spdlog/details/log_msg.h | 11 +- include/spdlog/details/log_msg_buffer-inl.h | 21 +- include/spdlog/details/log_msg_buffer.h | 5 +- include/spdlog/details/mpmc_blocking_q.h | 83 +- include/spdlog/details/null_mutex.h | 22 +- include/spdlog/details/os-inl.h | 344 ++++----- include/spdlog/details/os.h | 24 +- include/spdlog/details/periodic_worker-inl.h | 8 +- include/spdlog/details/periodic_worker.h | 19 +- include/spdlog/details/registry-inl.h | 160 ++-- include/spdlog/details/registry.h | 12 +- include/spdlog/details/synchronous_factory.h | 8 +- include/spdlog/details/tcp_client-windows.h | 80 +- include/spdlog/details/tcp_client.h | 64 +- include/spdlog/details/thread_pool-inl.h | 96 +-- include/spdlog/details/thread_pool.h | 49 +- include/spdlog/details/udp_client-windows.h | 61 +- include/spdlog/details/udp_client.h | 50 +- include/spdlog/details/windows_include.h | 4 +- include/spdlog/fmt/bin_to_hex.h | 113 +-- include/spdlog/fmt/chrono.h | 20 +- include/spdlog/fmt/compile.h | 20 +- include/spdlog/fmt/fmt.h | 30 +- include/spdlog/fmt/ostr.h | 20 +- include/spdlog/fmt/ranges.h | 20 +- include/spdlog/fmt/std.h | 24 +- include/spdlog/fmt/xchar.h | 20 +- include/spdlog/formatter.h | 5 +- include/spdlog/logger-inl.h | 178 ++--- include/spdlog/logger.h | 252 +++--- include/spdlog/pattern_formatter-inl.h | 715 +++++++----------- include/spdlog/pattern_formatter.h | 61 +- include/spdlog/sinks/android_sink.h | 96 +-- include/spdlog/sinks/ansicolor_sink-inl.h | 81 +- include/spdlog/sinks/ansicolor_sink.h | 23 +- include/spdlog/sinks/base_sink.h | 7 +- include/spdlog/sinks/basic_file_sink-inl.h | 26 +- include/spdlog/sinks/basic_file_sink.h | 31 +- include/spdlog/sinks/callback_sink.h | 25 +- include/spdlog/sinks/daily_file_sink.h | 175 +++-- include/spdlog/sinks/dist_sink.h | 46 +- include/spdlog/sinks/dup_filter_sink.h | 40 +- include/spdlog/sinks/hourly_file_sink.h | 117 ++- include/spdlog/sinks/kafka_sink.h | 87 +-- include/spdlog/sinks/mongo_sink.h | 71 +- include/spdlog/sinks/msvc_sink.h | 39 +- include/spdlog/sinks/null_sink.h | 17 +- include/spdlog/sinks/ostream_sink.h | 21 +- include/spdlog/sinks/qt_sinks.h | 178 ++--- include/spdlog/sinks/ringbuffer_sink.h | 27 +- include/spdlog/sinks/rotating_file_sink-inl.h | 85 +-- include/spdlog/sinks/rotating_file_sink.h | 46 +- include/spdlog/sinks/sink-inl.h | 11 +- include/spdlog/sinks/sink.h | 5 +- include/spdlog/sinks/stdout_color_sinks-inl.h | 24 +- include/spdlog/sinks/stdout_color_sinks.h | 14 +- include/spdlog/sinks/stdout_sinks-inl.h | 88 +-- include/spdlog/sinks/stdout_sinks.h | 29 +- include/spdlog/sinks/syslog_sink.h | 73 +- include/spdlog/sinks/systemd_sink.h | 90 +-- include/spdlog/sinks/tcp_sink.h | 35 +- include/spdlog/sinks/udp_sink.h | 34 +- include/spdlog/sinks/win_eventlog_sink.h | 127 ++-- include/spdlog/sinks/wincolor_sink-inl.h | 105 +-- include/spdlog/sinks/wincolor_sink.h | 21 +- include/spdlog/spdlog-inl.h | 92 +-- include/spdlog/spdlog.h | 186 ++--- include/spdlog/stopwatch.h | 31 +- src/async.cpp | 2 +- src/bundled_fmtlib_format.cpp | 32 +- src/cfg.cpp | 2 +- src/color_sinks.cpp | 40 +- src/file_sinks.cpp | 6 +- src/spdlog.cpp | 19 +- src/stdout_sinks.cpp | 28 +- 92 files changed, 2365 insertions(+), 3537 deletions(-) diff --git a/include/spdlog/async.h b/include/spdlog/async.h index 94f9f6d9..cdbbfc43 100644 --- a/include/spdlog/async.h +++ b/include/spdlog/async.h @@ -18,9 +18,9 @@ #include #include +#include #include #include -#include namespace spdlog { @@ -31,12 +31,10 @@ static const size_t default_async_q_size = 8192; // async logger factory - creates async loggers backed with thread pool. // if a global thread pool doesn't already exist, create it with default queue // size of 8192 items and single thread. -template -struct async_factory_impl -{ - template - static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) - { +template +struct async_factory_impl { + template + static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { auto ®istry_inst = details::registry::instance(); // create global thread pool if not already exists.. @@ -44,14 +42,14 @@ struct async_factory_impl auto &mutex = registry_inst.tp_mutex(); std::lock_guard tp_lock(mutex); auto tp = registry_inst.get_tp(); - if (tp == nullptr) - { + if (tp == nullptr) { tp = std::make_shared(details::default_async_q_size, 1U); registry_inst.set_tp(tp); } auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); + auto new_logger = + std::make_shared(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); registry_inst.initialize_logger(new_logger); return new_logger; } @@ -60,40 +58,34 @@ struct async_factory_impl using async_factory = async_factory_impl; using async_factory_nonblock = async_factory_impl; -template -inline std::shared_ptr create_async(std::string logger_name, SinkArgs &&...sink_args) -{ +template +inline std::shared_ptr create_async(std::string logger_name, SinkArgs &&...sink_args) { return async_factory::create(std::move(logger_name), std::forward(sink_args)...); } -template -inline std::shared_ptr create_async_nb(std::string logger_name, SinkArgs &&...sink_args) -{ +template +inline std::shared_ptr create_async_nb(std::string logger_name, SinkArgs &&...sink_args) { return async_factory_nonblock::create(std::move(logger_name), std::forward(sink_args)...); } // set global thread pool. -inline void init_thread_pool( - size_t q_size, size_t thread_count, std::function on_thread_start, std::function on_thread_stop) -{ +inline void init_thread_pool(size_t q_size, + size_t thread_count, + std::function on_thread_start, + std::function on_thread_stop) { auto tp = std::make_shared(q_size, thread_count, on_thread_start, on_thread_stop); 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, [] {}); } -inline void init_thread_pool(size_t q_size, size_t thread_count) -{ +inline void init_thread_pool(size_t q_size, size_t thread_count) { init_thread_pool( q_size, thread_count, [] {}, [] {}); } // get the global thread pool. -inline std::shared_ptr thread_pool() -{ - return details::registry::instance().get_tp(); -} +inline std::shared_ptr thread_pool() { return details::registry::instance().get_tp(); } } // namespace spdlog diff --git a/include/spdlog/async_logger-inl.h b/include/spdlog/async_logger-inl.h index 13da5940..edce9d68 100644 --- a/include/spdlog/async_logger-inl.h +++ b/include/spdlog/async_logger-inl.h @@ -4,96 +4,73 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include +#include #include #include -SPDLOG_INLINE spdlog::async_logger::async_logger( - std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) - : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) -{} +SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, + sinks_init_list sinks_list, + std::weak_ptr tp, + async_overflow_policy overflow_policy) + : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) {} -SPDLOG_INLINE spdlog::async_logger::async_logger( - std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) - : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) -{} +SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, + sink_ptr single_sink, + std::weak_ptr tp, + async_overflow_policy overflow_policy) + : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} // send the log message to the thread pool -SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg) -{ - SPDLOG_TRY - { - if (auto pool_ptr = thread_pool_.lock()) - { - pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); - } - else - { - throw_spdlog_ex("async log: thread pool doesn't exist anymore"); - } - } - SPDLOG_LOGGER_CATCH(msg.source) +SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){ + SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); +} +else { + throw_spdlog_ex("async log: thread pool doesn't exist anymore"); +} +} +SPDLOG_LOGGER_CATCH(msg.source) } // send flush request to the thread pool -SPDLOG_INLINE void spdlog::async_logger::flush_() -{ - SPDLOG_TRY - { - if (auto pool_ptr = thread_pool_.lock()) - { - pool_ptr->post_flush(shared_from_this(), overflow_policy_); - } - else - { - throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); - } - } - SPDLOG_LOGGER_CATCH(source_loc()) +SPDLOG_INLINE void spdlog::async_logger::flush_(){ + SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_flush(shared_from_this(), overflow_policy_); +} +else { + throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); +} +} +SPDLOG_LOGGER_CATCH(source_loc()) } // // backend functions - called from the thread pool to do the actual job // -SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) -{ - for (auto &sink : sinks_) - { - if (sink->should_log(msg.level)) - { - SPDLOG_TRY - { - sink->log(msg); - } +SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { + for (auto &sink : sinks_) { + if (sink->should_log(msg.level)) { + SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } - if (should_flush_(msg)) - { + if (should_flush_(msg)) { backend_flush_(); } } -SPDLOG_INLINE void spdlog::async_logger::backend_flush_() -{ - for (auto &sink : sinks_) - { - SPDLOG_TRY - { - sink->flush(); - } +SPDLOG_INLINE void spdlog::async_logger::backend_flush_() { + for (auto &sink : sinks_) { + SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } -SPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) -{ +SPDLOG_INLINE std::shared_ptr spdlog::async_logger::clone(std::string new_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(new_name); return cloned; diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index e979ead7..2e4f2706 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -19,8 +19,7 @@ namespace spdlog { // Async overflow policy - block by default. -enum class async_overflow_policy -{ +enum class async_overflow_policy { block, // Block until message can be enqueued overrun_oldest, // Discard oldest message in the queue if full when trying to // add new item. @@ -31,24 +30,29 @@ namespace details { class thread_pool; } -class SPDLOG_API async_logger final : public std::enable_shared_from_this, public logger -{ +class SPDLOG_API async_logger final : public std::enable_shared_from_this, public logger { friend class details::thread_pool; public: - template - async_logger(std::string logger_name, It begin, It end, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block) - : logger(std::move(logger_name), begin, end) - , thread_pool_(std::move(tp)) - , overflow_policy_(overflow_policy) - {} + template + async_logger(std::string logger_name, + It begin, + It end, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block) + : logger(std::move(logger_name), begin, end), + thread_pool_(std::move(tp)), + overflow_policy_(overflow_policy) {} - async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); + async_logger(std::string logger_name, + sinks_init_list sinks_list, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); - async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); + async_logger(std::string logger_name, + sink_ptr single_sink, + std::weak_ptr tp, + async_overflow_policy overflow_policy = async_overflow_policy::block); std::shared_ptr clone(std::string new_name) override; @@ -65,5 +69,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "async_logger-inl.h" + #include "async_logger-inl.h" #endif diff --git a/include/spdlog/cfg/argv.h b/include/spdlog/cfg/argv.h index 36d9f1c4..4c3bac19 100644 --- a/include/spdlog/cfg/argv.h +++ b/include/spdlog/cfg/argv.h @@ -21,24 +21,18 @@ namespace spdlog { namespace cfg { // search for SPDLOG_LEVEL= in the args and use it to init the levels -inline void load_argv_levels(int argc, const char **argv) -{ +inline void load_argv_levels(int argc, const char **argv) { const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; - for (int i = 1; i < argc; i++) - { + for (int i = 1; i < argc; i++) { std::string arg = argv[i]; - if (arg.find(spdlog_level_prefix) == 0) - { + if (arg.find(spdlog_level_prefix) == 0) { auto levels_string = arg.substr(spdlog_level_prefix.size()); helpers::load_levels(levels_string); } } } -inline void load_argv_levels(int argc, char **argv) -{ - load_argv_levels(argc, const_cast(argv)); -} +inline void load_argv_levels(int argc, char **argv) { load_argv_levels(argc, const_cast(argv)); } } // namespace cfg } // namespace spdlog diff --git a/include/spdlog/cfg/env.h b/include/spdlog/cfg/env.h index 1f39ebbb..e445a1c6 100644 --- a/include/spdlog/cfg/env.h +++ b/include/spdlog/cfg/env.h @@ -3,8 +3,8 @@ #pragma once #include -#include #include +#include // // Init levels and patterns from env variables SPDLOG_LEVEL @@ -25,11 +25,9 @@ namespace spdlog { namespace cfg { -inline void load_env_levels() -{ +inline void load_env_levels() { auto env_val = details::os::getenv("SPDLOG_LEVEL"); - if (!env_val.empty()) - { + if (!env_val.empty()) { helpers::load_levels(env_val); } } diff --git a/include/spdlog/cfg/helpers-inl.h b/include/spdlog/cfg/helpers-inl.h index 675a13af..95dce058 100644 --- a/include/spdlog/cfg/helpers-inl.h +++ b/include/spdlog/cfg/helpers-inl.h @@ -4,33 +4,31 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include #include +#include #include +#include #include #include -#include namespace spdlog { namespace cfg { namespace helpers { // inplace convert to lowercase -inline std::string &to_lower_(std::string &str) -{ - std::transform( - str.begin(), str.end(), str.begin(), [](char ch) { return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); }); +inline std::string &to_lower_(std::string &str) { + std::transform(str.begin(), str.end(), str.begin(), + [](char ch) { return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); }); return str; } // inplace trim spaces -inline std::string &trim_(std::string &str) -{ +inline std::string &trim_(std::string &str) { const char *spaces = " \n\r\t"; str.erase(str.find_last_not_of(spaces) + 1); str.erase(0, str.find_first_not_of(spaces)); @@ -44,16 +42,12 @@ inline std::string &trim_(std::string &str) // "key=" => ("key", "") // "val" => ("", "val") -inline std::pair extract_kv_(char sep, const std::string &str) -{ +inline std::pair extract_kv_(char sep, const std::string &str) { auto n = str.find(sep); std::string k, v; - if (n == std::string::npos) - { + if (n == std::string::npos) { v = str; - } - else - { + } else { k = str.substr(0, n); v = str.substr(n + 1); } @@ -62,15 +56,12 @@ inline std::pair extract_kv_(char sep, const std::stri // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} -inline std::unordered_map extract_key_vals_(const std::string &str) -{ +inline std::unordered_map extract_key_vals_(const std::string &str) { std::string token; std::istringstream token_stream(str); std::unordered_map rv{}; - while (std::getline(token_stream, token, ',')) - { - if (token.empty()) - { + while (std::getline(token_stream, token, ',')) { + if (token.empty()) { continue; } auto kv = extract_kv_('=', token); @@ -79,10 +70,8 @@ inline std::unordered_map extract_key_vals_(const std: return rv; } -SPDLOG_INLINE void load_levels(const std::string &input) -{ - if (input.empty() || input.size() > 512) - { +SPDLOG_INLINE void load_levels(const std::string &input) { + if (input.empty() || input.size() > 512) { return; } @@ -91,23 +80,19 @@ SPDLOG_INLINE void load_levels(const std::string &input) level::level_enum global_level = level::info; bool global_level_found = false; - for (auto &name_level : key_vals) - { + for (auto &name_level : key_vals) { auto &logger_name = name_level.first; auto level_name = to_lower_(name_level.second); auto level = level::from_str(level_name); // ignore unrecognized level names - if (level == level::off && level_name != "off") - { + if (level == level::off && level_name != "off") { continue; } if (logger_name.empty()) // no logger name indicate global level { global_level_found = true; global_level = level; - } - else - { + } else { levels[logger_name] = level; } } diff --git a/include/spdlog/cfg/helpers.h b/include/spdlog/cfg/helpers.h index ab7584e0..bf18d253 100644 --- a/include/spdlog/cfg/helpers.h +++ b/include/spdlog/cfg/helpers.h @@ -25,5 +25,5 @@ SPDLOG_API void load_levels(const std::string &txt); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "helpers-inl.h" + #include "helpers-inl.h" #endif // SPDLOG_HEADER_ONLY diff --git a/include/spdlog/common-inl.h b/include/spdlog/common-inl.h index 728f9831..8c9b255e 100644 --- a/include/spdlog/common-inl.h +++ b/include/spdlog/common-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -20,29 +20,22 @@ constexpr static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; -SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return level_string_views[l]; } -SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT -{ - return short_level_names[l]; -} +SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { return short_level_names[l]; } -SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT { auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); if (it != std::end(level_string_views)) return static_cast(std::distance(std::begin(level_string_views), it)); // check also for "warn" and "err" before giving up.. - if (name == "warn") - { + if (name == "warn") { return level::warn; } - if (name == "err") - { + if (name == "err") { return level::err; } return level::off; @@ -50,11 +43,9 @@ SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG } // namespace level SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) - : msg_(std::move(msg)) -{} + : msg_(std::move(msg)) {} -SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) -{ +SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) { #ifdef SPDLOG_USE_STD_FORMAT msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); #else @@ -64,19 +55,10 @@ SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) #endif } -SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT -{ - return msg_.c_str(); -} +SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); } -SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) -{ - SPDLOG_THROW(spdlog_ex(msg, last_errno)); -} +SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); } -SPDLOG_INLINE void throw_spdlog_ex(std::string msg) -{ - SPDLOG_THROW(spdlog_ex(std::move(msg))); -} +SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } } // namespace spdlog diff --git a/include/spdlog/common.h b/include/spdlog/common.h index 0a262eb2..94823fe6 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -3,112 +3,111 @@ #pragma once -#include #include +#include #include #include +#include +#include +#include #include #include -#include #include #include -#include -#include #ifdef SPDLOG_USE_STD_FORMAT -# include -# if __cpp_lib_format >= 202207L -# include -# else -# include -# endif + #include + #if __cpp_lib_format >= 202207L + #include + #else + #include + #endif #endif #ifdef SPDLOG_COMPILED_LIB -# undef SPDLOG_HEADER_ONLY -# if defined(SPDLOG_SHARED_LIB) -# if defined(_WIN32) -# ifdef spdlog_EXPORTS -# define SPDLOG_API __declspec(dllexport) -# else // !spdlog_EXPORTS -# define SPDLOG_API __declspec(dllimport) -# endif -# else // !defined(_WIN32) -# define SPDLOG_API __attribute__((visibility("default"))) -# endif -# else // !defined(SPDLOG_SHARED_LIB) -# define SPDLOG_API -# endif -# define SPDLOG_INLINE + #undef SPDLOG_HEADER_ONLY + #if defined(SPDLOG_SHARED_LIB) + #if defined(_WIN32) + #ifdef spdlog_EXPORTS + #define SPDLOG_API __declspec(dllexport) + #else // !spdlog_EXPORTS + #define SPDLOG_API __declspec(dllimport) + #endif + #else // !defined(_WIN32) + #define SPDLOG_API __attribute__((visibility("default"))) + #endif + #else // !defined(SPDLOG_SHARED_LIB) + #define SPDLOG_API + #endif + #define SPDLOG_INLINE #else // !defined(SPDLOG_COMPILED_LIB) -# define SPDLOG_API -# define SPDLOG_HEADER_ONLY -# define SPDLOG_INLINE inline + #define SPDLOG_API + #define SPDLOG_HEADER_ONLY + #define SPDLOG_INLINE inline #endif // #ifdef SPDLOG_COMPILED_LIB #include #if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 -# define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) -# define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) -# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -# include -# endif + #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) + #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #include + #endif #else -# define SPDLOG_FMT_RUNTIME(format_string) format_string -# define SPDLOG_FMT_STRING(format_string) format_string + #define SPDLOG_FMT_RUNTIME(format_string) format_string + #define SPDLOG_FMT_STRING(format_string) format_string #endif // visual studio up to 2013 does not support noexcept nor constexpr #if defined(_MSC_VER) && (_MSC_VER < 1900) -# define SPDLOG_NOEXCEPT _NOEXCEPT -# define SPDLOG_CONSTEXPR -# define SPDLOG_CONSTEXPR_FUNC inline + #define SPDLOG_NOEXCEPT _NOEXCEPT + #define SPDLOG_CONSTEXPR + #define SPDLOG_CONSTEXPR_FUNC inline #else -# define SPDLOG_NOEXCEPT noexcept -# define SPDLOG_CONSTEXPR constexpr -# if __cplusplus >= 201402L -# define SPDLOG_CONSTEXPR_FUNC constexpr -# else -# define SPDLOG_CONSTEXPR_FUNC inline -# endif + #define SPDLOG_NOEXCEPT noexcept + #define SPDLOG_CONSTEXPR constexpr + #if __cplusplus >= 201402L + #define SPDLOG_CONSTEXPR_FUNC constexpr + #else + #define SPDLOG_CONSTEXPR_FUNC inline + #endif #endif #if defined(__GNUC__) || defined(__clang__) -# define SPDLOG_DEPRECATED __attribute__((deprecated)) + #define SPDLOG_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) -# define SPDLOG_DEPRECATED __declspec(deprecated) + #define SPDLOG_DEPRECATED __declspec(deprecated) #else -# define SPDLOG_DEPRECATED + #define SPDLOG_DEPRECATED #endif // disable thread local on msvc 2013 #ifndef SPDLOG_NO_TLS -# if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) -# define SPDLOG_NO_TLS 1 -# endif + #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) + #define SPDLOG_NO_TLS 1 + #endif #endif #ifndef SPDLOG_FUNCTION -# define SPDLOG_FUNCTION static_cast(__FUNCTION__) + #define SPDLOG_FUNCTION static_cast(__FUNCTION__) #endif #ifdef SPDLOG_NO_EXCEPTIONS -# define SPDLOG_TRY -# define SPDLOG_THROW(ex) \ - do \ - { \ - printf("spdlog fatal error: %s\n", ex.what()); \ - std::abort(); \ + #define SPDLOG_TRY + #define SPDLOG_THROW(ex) \ + do { \ + printf("spdlog fatal error: %s\n", ex.what()); \ + std::abort(); \ } while (0) -# define SPDLOG_CATCH_STD + #define SPDLOG_CATCH_STD #else -# define SPDLOG_TRY try -# define SPDLOG_THROW(ex) throw(ex) -# define SPDLOG_CATCH_STD \ - catch (const std::exception &) \ - {} + #define SPDLOG_TRY try + #define SPDLOG_THROW(ex) throw(ex) + #define SPDLOG_CATCH_STD \ + catch (const std::exception &) { \ + } #endif namespace spdlog { @@ -121,12 +120,12 @@ class sink; #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) using filename_t = std::wstring; -// allow macro expansion to occur in SPDLOG_FILENAME_T -# define SPDLOG_FILENAME_T_INNER(s) L##s -# define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) + // allow macro expansion to occur in SPDLOG_FILENAME_T + #define SPDLOG_FILENAME_T_INNER(s) L##s + #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) #else using filename_t = std::string; -# define SPDLOG_FILENAME_T(s) s + #define SPDLOG_FILENAME_T(s) s #endif using log_clock = std::chrono::system_clock; @@ -139,76 +138,78 @@ namespace fmt_lib = std; using string_view_t = std::string_view; using memory_buf_t = std::string; -template -# if __cpp_lib_format >= 202207L +template + #if __cpp_lib_format >= 202207L using format_string_t = std::format_string; -# else + #else using format_string_t = std::string_view; -# endif + #endif -template -struct is_convertible_to_basic_format_string : std::integral_constant>::value> -{}; +template +struct is_convertible_to_basic_format_string + : std::integral_constant>::value> {}; -# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) using wstring_view_t = std::wstring_view; using wmemory_buf_t = std::wstring; -template -# if __cpp_lib_format >= 202207L +template + #if __cpp_lib_format >= 202207L using wformat_string_t = std::wformat_string; -# else + #else using wformat_string_t = std::wstring_view; -# endif -# endif -# define SPDLOG_BUF_TO_STRING(x) x + #endif + #endif + #define SPDLOG_BUF_TO_STRING(x) x #else // use fmt lib instead of std::format namespace fmt_lib = fmt; using string_view_t = fmt::basic_string_view; using memory_buf_t = fmt::basic_memory_buffer; -template +template using format_string_t = fmt::format_string; -template +template using remove_cvref_t = typename std::remove_cv::type>::type; -template -# if FMT_VERSION >= 90101 +template + #if FMT_VERSION >= 90101 using fmt_runtime_string = fmt::runtime_format_string; -# else + #else using fmt_runtime_string = fmt::basic_runtime; -# endif + #endif -// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here, -// in addition, fmt::basic_runtime is only convertible to basic_format_string but not basic_string_view -template +// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from +// basic_format_string here, in addition, fmt::basic_runtime is only convertible to basic_format_string but +// not basic_string_view +template struct is_convertible_to_basic_format_string : std::integral_constant>::value || std::is_same, fmt_runtime_string>::value> -{}; + std::is_convertible>::value || + std::is_same, fmt_runtime_string>::value> {}; -# if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) using wstring_view_t = fmt::basic_string_view; using wmemory_buf_t = fmt::basic_memory_buffer; -template +template using wformat_string_t = fmt::wformat_string; -# endif -# define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) + #endif + #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) #endif #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -# ifndef _WIN32 -# error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows -# endif // _WIN32 + #ifndef _WIN32 + #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows + #endif // _WIN32 #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT -template -struct is_convertible_to_any_format_string : std::integral_constant::value || - is_convertible_to_basic_format_string::value> -{}; +template +struct is_convertible_to_any_format_string + : std::integral_constant::value || + is_convertible_to_basic_format_string::value> {}; #if defined(SPDLOG_NO_ATOMIC_LEVELS) using level_t = details::null_atomic_int; @@ -225,13 +226,12 @@ using level_t = std::atomic; #define SPDLOG_LEVEL_OFF 6 #if !defined(SPDLOG_ACTIVE_LEVEL) -# define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO + #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO #endif // Log level enum namespace level { -enum level_enum : int -{ +enum level_enum : int { trace = SPDLOG_LEVEL_TRACE, debug = SPDLOG_LEVEL_DEBUG, info = SPDLOG_LEVEL_INFO, @@ -251,19 +251,17 @@ enum level_enum : int #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3) #if !defined(SPDLOG_LEVEL_NAMES) -# define SPDLOG_LEVEL_NAMES \ - { \ - SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, \ - SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF \ + #define SPDLOG_LEVEL_NAMES \ + { \ + SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, SPDLOG_LEVEL_NAME_WARNING, \ + SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, SPDLOG_LEVEL_NAME_OFF \ } #endif #if !defined(SPDLOG_SHORT_LEVEL_NAMES) -# define SPDLOG_SHORT_LEVEL_NAMES \ - { \ - "T", "D", "I", "W", "E", "C", "O" \ - } + #define SPDLOG_SHORT_LEVEL_NAMES \ + { "T", "D", "I", "W", "E", "C", "O" } #endif SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; @@ -275,19 +273,13 @@ SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NO // // Color mode used by sinks with color support. // -enum class color_mode -{ - always, - automatic, - never -}; +enum class color_mode { always, automatic, never }; // // Pattern time - specific time getting to use for pattern_formatter. // local time by default // -enum class pattern_time_type -{ +enum class pattern_time_type { local, // log localtime utc // log utc }; @@ -295,8 +287,7 @@ enum class pattern_time_type // // Log exception // -class SPDLOG_API spdlog_ex : public std::exception -{ +class SPDLOG_API spdlog_ex : public std::exception { public: explicit spdlog_ex(std::string msg); spdlog_ex(const std::string &msg, int last_errno); @@ -309,32 +300,25 @@ private: [[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno); [[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); -struct source_loc -{ +struct source_loc { SPDLOG_CONSTEXPR source_loc() = default; SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in) - : filename{filename_in} - , line{line_in} - , funcname{funcname_in} - {} + : filename{filename_in}, + line{line_in}, + funcname{funcname_in} {} - SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT - { - return line == 0; - } + SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line == 0; } const char *filename{nullptr}; int line{0}; const char *funcname{nullptr}; }; -struct file_event_handlers -{ +struct file_event_handlers { file_event_handlers() - : before_open(nullptr) - , after_open(nullptr) - , before_close(nullptr) - , after_close(nullptr) - {} + : before_open(nullptr), + after_open(nullptr), + before_close(nullptr), + after_close(nullptr) {} std::function before_open; std::function after_open; @@ -346,38 +330,29 @@ namespace details { // to_string_view -SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT -{ +SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT { return spdlog::string_view_t{buf.data(), buf.size()}; } -SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT -{ - return str; -} +SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT { return str; } #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT -{ +SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT { return spdlog::wstring_view_t{buf.data(), buf.size()}; } -SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT -{ - return str; -} +SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT { return str; } #endif #ifndef SPDLOG_USE_STD_FORMAT -template -inline fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) -{ +template +inline fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) { return fmt; } #elif __cpp_lib_format >= 202207L -template -SPDLOG_CONSTEXPR_FUNC std::basic_string_view to_string_view(std::basic_format_string fmt) SPDLOG_NOEXCEPT -{ +template +SPDLOG_CONSTEXPR_FUNC std::basic_string_view +to_string_view(std::basic_format_string fmt) SPDLOG_NOEXCEPT { return fmt.get(); } #endif @@ -388,27 +363,24 @@ SPDLOG_CONSTEXPR_FUNC std::basic_string_view to_string_view(std::basic_format using std::enable_if_t; using std::make_unique; #else -template +template using enable_if_t = typename std::enable_if::type; -template -std::unique_ptr make_unique(Args &&...args) -{ +template +std::unique_ptr make_unique(Args &&...args) { static_assert(!std::is_array::value, "arrays not supported"); return std::unique_ptr(new T(std::forward(args)...)); } #endif // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) -template::value, int> = 0> -constexpr T conditional_static_cast(U value) -{ +template ::value, int> = 0> +constexpr T conditional_static_cast(U value) { return static_cast(value); } -template::value, int> = 0> -constexpr T conditional_static_cast(U value) -{ +template ::value, int> = 0> +constexpr T conditional_static_cast(U value) { return value; } @@ -416,5 +388,5 @@ constexpr T conditional_static_cast(U value) } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "common-inl.h" + #include "common-inl.h" #endif diff --git a/include/spdlog/details/backtracer-inl.h b/include/spdlog/details/backtracer-inl.h index 40eba408..5e57d1c2 100644 --- a/include/spdlog/details/backtracer-inl.h +++ b/include/spdlog/details/backtracer-inl.h @@ -4,68 +4,56 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif namespace spdlog { namespace details { -SPDLOG_INLINE backtracer::backtracer(const backtracer &other) -{ +SPDLOG_INLINE backtracer::backtracer(const backtracer &other) { std::lock_guard lock(other.mutex_); enabled_ = other.enabled(); messages_ = other.messages_; } -SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT { std::lock_guard lock(other.mutex_); enabled_ = other.enabled(); messages_ = std::move(other.messages_); } -SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) -{ +SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) { std::lock_guard lock(mutex_); enabled_ = other.enabled(); messages_ = std::move(other.messages_); return *this; } -SPDLOG_INLINE void backtracer::enable(size_t size) -{ +SPDLOG_INLINE void backtracer::enable(size_t size) { std::lock_guard lock{mutex_}; enabled_.store(true, std::memory_order_relaxed); messages_ = circular_q{size}; } -SPDLOG_INLINE void backtracer::disable() -{ +SPDLOG_INLINE void backtracer::disable() { std::lock_guard lock{mutex_}; enabled_.store(false, std::memory_order_relaxed); } -SPDLOG_INLINE bool backtracer::enabled() const -{ - return enabled_.load(std::memory_order_relaxed); -} +SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); } -SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) -{ +SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) { std::lock_guard lock{mutex_}; messages_.push_back(log_msg_buffer{msg}); } -SPDLOG_INLINE bool backtracer::empty() const -{ +SPDLOG_INLINE bool backtracer::empty() const { std::lock_guard lock{mutex_}; return messages_.empty(); } // pop all items in the q and apply the given fun on each of them. -SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) -{ +SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) { std::lock_guard lock{mutex_}; - while (!messages_.empty()) - { + while (!messages_.empty()) { auto &front_msg = messages_.front(); fun(front_msg); messages_.pop_front(); diff --git a/include/spdlog/details/backtracer.h b/include/spdlog/details/backtracer.h index 13785d85..4ab1b071 100644 --- a/include/spdlog/details/backtracer.h +++ b/include/spdlog/details/backtracer.h @@ -3,20 +3,19 @@ #pragma once -#include #include +#include #include -#include #include +#include // Store log messages in circular buffer. // Useful for storing debug data in case of error/warning happens. namespace spdlog { namespace details { -class SPDLOG_API backtracer -{ +class SPDLOG_API backtracer { mutable std::mutex mutex_; std::atomic enabled_{false}; circular_q messages_; @@ -42,5 +41,5 @@ public: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "backtracer-inl.h" + #include "backtracer-inl.h" #endif diff --git a/include/spdlog/details/circular_q.h b/include/spdlog/details/circular_q.h index e4fd5fd4..76ac1f1c 100644 --- a/include/spdlog/details/circular_q.h +++ b/include/spdlog/details/circular_q.h @@ -4,14 +4,13 @@ // circular q view of std::vector. #pragma once -#include #include +#include namespace spdlog { namespace details { -template -class circular_q -{ +template +class circular_q { size_t max_items_ = 0; typename std::vector::size_type head_ = 0; typename std::vector::size_type tail_ = 0; @@ -26,30 +25,24 @@ public: explicit circular_q(size_t max_items) : max_items_(max_items + 1) // one item is reserved as marker for full q - , v_(max_items_) - {} + , + v_(max_items_) {} circular_q(const circular_q &) = default; circular_q &operator=(const circular_q &) = default; // move cannot be default, // since we need to reset head_, tail_, etc to zero in the moved object - circular_q(circular_q &&other) SPDLOG_NOEXCEPT - { - copy_moveable(std::move(other)); - } + circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); } - circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT - { + circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); return *this; } // push back, overrun (oldest) item if no room left - void push_back(T &&item) - { - if (max_items_ > 0) - { + void push_back(T &&item) { + if (max_items_ > 0) { v_[tail_] = std::move(item); tail_ = (tail_ + 1) % max_items_; @@ -63,73 +56,47 @@ public: // Return reference to the front item. // If there are no elements in the container, the behavior is undefined. - const T &front() const - { - return v_[head_]; - } + const T &front() const { return v_[head_]; } - T &front() - { - return v_[head_]; - } + T &front() { return v_[head_]; } // Return number of elements actually stored - size_t size() const - { - if (tail_ >= head_) - { + size_t size() const { + if (tail_ >= head_) { return tail_ - head_; - } - else - { + } else { return max_items_ - (head_ - tail_); } } // Return const reference to item by index. // If index is out of range 0…size()-1, the behavior is undefined. - const T &at(size_t i) const - { + const T &at(size_t i) const { assert(i < size()); return v_[(head_ + i) % max_items_]; } // Pop item from front. // If there are no elements in the container, the behavior is undefined. - void pop_front() - { - head_ = (head_ + 1) % max_items_; - } + void pop_front() { head_ = (head_ + 1) % max_items_; } - bool empty() const - { - return tail_ == head_; - } + bool empty() const { return tail_ == head_; } - bool full() const - { + bool full() const { // head is ahead of the tail by 1 - if (max_items_ > 0) - { + if (max_items_ > 0) { return ((tail_ + 1) % max_items_) == head_; } return false; } - size_t overrun_counter() const - { - return overrun_counter_; - } + size_t overrun_counter() const { return overrun_counter_; } - void reset_overrun_counter() - { - overrun_counter_ = 0; - } + void reset_overrun_counter() { overrun_counter_ = 0; } private: // copy from other&& and reset it to disabled state - void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT - { + void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT { max_items_ = other.max_items_; head_ = other.head_; tail_ = other.tail_; diff --git a/include/spdlog/details/console_globals.h b/include/spdlog/details/console_globals.h index 665201dd..649afb3e 100644 --- a/include/spdlog/details/console_globals.h +++ b/include/spdlog/details/console_globals.h @@ -3,27 +3,23 @@ #pragma once -#include #include +#include namespace spdlog { namespace details { -struct console_mutex -{ +struct console_mutex { using mutex_t = std::mutex; - static mutex_t &mutex() - { + static mutex_t &mutex() { static mutex_t s_mutex; return s_mutex; } }; -struct console_nullmutex -{ +struct console_nullmutex { using mutex_t = null_mutex; - static mutex_t &mutex() - { + static mutex_t &mutex() { static mutex_t s_mutex; return s_mutex; } diff --git a/include/spdlog/details/file_helper-inl.h b/include/spdlog/details/file_helper-inl.h index 74c89a87..d1e15751 100644 --- a/include/spdlog/details/file_helper-inl.h +++ b/include/spdlog/details/file_helper-inl.h @@ -4,11 +4,11 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include +#include #include #include @@ -21,47 +21,36 @@ namespace spdlog { namespace details { SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) - : event_handlers_(event_handlers) -{} + : event_handlers_(event_handlers) {} -SPDLOG_INLINE file_helper::~file_helper() -{ - close(); -} +SPDLOG_INLINE file_helper::~file_helper() { close(); } -SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) -{ +SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) { close(); filename_ = fname; auto *mode = SPDLOG_FILENAME_T("ab"); auto *trunc_mode = SPDLOG_FILENAME_T("wb"); - if (event_handlers_.before_open) - { + if (event_handlers_.before_open) { event_handlers_.before_open(filename_); } - for (int tries = 0; tries < open_tries_; ++tries) - { + for (int tries = 0; tries < open_tries_; ++tries) { // create containing folder if not exists already. os::create_dir(os::dir_name(fname)); - if (truncate) - { + if (truncate) { // Truncate by opening-and-closing a tmp file in "wb" mode, always // opening the actual log-we-write-to in "ab" mode, since that // interacts more politely with eternal processes that might // rotate/truncate the file underneath us. std::FILE *tmp; - if (os::fopen_s(&tmp, fname, trunc_mode)) - { + if (os::fopen_s(&tmp, fname, trunc_mode)) { continue; } std::fclose(tmp); } - if (!os::fopen_s(&fd_, fname, mode)) - { - if (event_handlers_.after_open) - { + if (!os::fopen_s(&fd_, fname, mode)) { + if (event_handlers_.after_open) { event_handlers_.after_open(filename_, fd_); } return; @@ -73,73 +62,56 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); } -SPDLOG_INLINE void file_helper::reopen(bool truncate) -{ - if (filename_.empty()) - { +SPDLOG_INLINE void file_helper::reopen(bool truncate) { + if (filename_.empty()) { throw_spdlog_ex("Failed re opening file - was not opened before"); } this->open(filename_, truncate); } -SPDLOG_INLINE void file_helper::flush() -{ - if (std::fflush(fd_) != 0) - { +SPDLOG_INLINE void file_helper::flush() { + if (std::fflush(fd_) != 0) { throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); } } -SPDLOG_INLINE void file_helper::sync() -{ - if (!os::fsync(fd_)) - { +SPDLOG_INLINE void file_helper::sync() { + if (!os::fsync(fd_)) { throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); } } -SPDLOG_INLINE void file_helper::close() -{ - if (fd_ != nullptr) - { - if (event_handlers_.before_close) - { +SPDLOG_INLINE void file_helper::close() { + if (fd_ != nullptr) { + if (event_handlers_.before_close) { event_handlers_.before_close(filename_, fd_); } std::fclose(fd_); fd_ = nullptr; - if (event_handlers_.after_close) - { + if (event_handlers_.after_close) { event_handlers_.after_close(filename_); } } } -SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) -{ +SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) { size_t msg_size = buf.size(); auto data = buf.data(); - if (std::fwrite(data, 1, msg_size, fd_) != msg_size) - { + if (std::fwrite(data, 1, msg_size, fd_) != msg_size) { throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); } } -SPDLOG_INLINE size_t file_helper::size() const -{ - if (fd_ == nullptr) - { +SPDLOG_INLINE size_t file_helper::size() const { + if (fd_ == nullptr) { throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); } return os::filesize(fd_); } -SPDLOG_INLINE const filename_t &file_helper::filename() const -{ - return filename_; -} +SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; } // // return file path and its extension: @@ -154,21 +126,18 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const // ".mylog" => (".mylog". "") // "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") -SPDLOG_INLINE std::tuple file_helper::split_by_extension(const filename_t &fname) -{ +SPDLOG_INLINE std::tuple file_helper::split_by_extension(const filename_t &fname) { auto ext_index = fname.rfind('.'); // no valid extension found - return whole path and empty string as // extension - if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) - { + if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) { return std::make_tuple(fname, filename_t()); } // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" auto folder_index = fname.find_last_of(details::os::folder_seps_filename); - if (folder_index != filename_t::npos && folder_index >= ext_index - 1) - { + if (folder_index != filename_t::npos && folder_index >= ext_index - 1) { return std::make_tuple(fname, filename_t()); } diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index f42a5eb1..56d7d02c 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -13,8 +13,7 @@ namespace details { // When failing to open a file, retry several times(5) with a delay interval(10 ms). // Throw spdlog_ex exception on errors. -class SPDLOG_API file_helper -{ +class SPDLOG_API file_helper { public: file_helper() = default; explicit file_helper(const file_event_handlers &event_handlers); @@ -58,5 +57,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "file_helper-inl.h" + #include "file_helper-inl.h" #endif diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h index d9867180..1d2fcedb 100644 --- a/include/spdlog/details/fmt_helper.h +++ b/include/spdlog/details/fmt_helper.h @@ -3,14 +3,14 @@ #pragma once #include -#include #include -#include #include +#include +#include #ifdef SPDLOG_USE_STD_FORMAT -# include -# include + #include + #include #endif // Some fmt helpers to efficiently format and pad ints and strings @@ -18,46 +18,38 @@ namespace spdlog { namespace details { namespace fmt_helper { -inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) -{ +inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) { auto *buf_ptr = view.data(); dest.append(buf_ptr, buf_ptr + view.size()); } #ifdef SPDLOG_USE_STD_FORMAT -template -inline void append_int(T n, memory_buf_t &dest) -{ +template +inline void append_int(T n, memory_buf_t &dest) { // Buffer should be large enough to hold all digits (digits10 + 1) and a sign SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits::digits10 + 2; char buf[BUF_SIZE]; auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); - if (ec == std::errc()) - { + if (ec == std::errc()) { dest.append(buf, ptr); - } - else - { + } else { throw_spdlog_ex("Failed to format int", static_cast(ec)); } } #else -template -inline void append_int(T n, memory_buf_t &dest) -{ +template +inline void append_int(T n, memory_buf_t &dest) { fmt::format_int i(n); dest.append(i.data(), i.data() + i.size()); } #endif -template -SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) -{ +template +SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) { // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 unsigned int count = 1; - for (;;) - { + for (;;) { // 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. @@ -74,84 +66,72 @@ SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) } } -template -inline unsigned int count_digits(T n) -{ +template +inline unsigned int count_digits(T n) { using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; #ifdef SPDLOG_USE_STD_FORMAT return count_digits_fallback(static_cast(n)); #else return static_cast(fmt:: -// fmt 7.0.0 renamed the internal namespace to detail. -// See: https://github.com/fmtlib/fmt/issues/1538 -# if FMT_VERSION < 70000 - internal -# else - detail -# endif - ::count_digits(static_cast(n))); + // fmt 7.0.0 renamed the internal namespace to detail. + // See: https://github.com/fmtlib/fmt/issues/1538 + #if FMT_VERSION < 70000 + internal + #else + detail + #endif + ::count_digits(static_cast(n))); #endif } -inline void pad2(int n, memory_buf_t &dest) -{ +inline void pad2(int n, memory_buf_t &dest) { 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), SPDLOG_FMT_STRING("{:02}"), n); } } -template -inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) -{ +template +inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) { static_assert(std::is_unsigned::value, "pad_uint must get unsigned T"); - for (auto digits = count_digits(n); digits < width; digits++) - { + for (auto digits = count_digits(n); digits < width; digits++) { dest.push_back('0'); } append_int(n, dest); } -template -inline void pad3(T n, memory_buf_t &dest) -{ +template +inline void pad3(T n, memory_buf_t &dest) { static_assert(std::is_unsigned::value, "pad3 must get unsigned T"); - if (n < 1000) - { + if (n < 1000) { dest.push_back(static_cast(n / 100 + '0')); n = n % 100; dest.push_back(static_cast((n / 10) + '0')); dest.push_back(static_cast((n % 10) + '0')); - } - else - { + } else { append_int(n, dest); } } -template -inline void pad6(T n, memory_buf_t &dest) -{ +template +inline void pad6(T n, memory_buf_t &dest) { pad_uint(n, 6, dest); } -template -inline void pad9(T n, memory_buf_t &dest) -{ +template +inline void pad9(T n, memory_buf_t &dest) { pad_uint(n, 9, dest); } // return fraction of a second of the given time_point. // e.g. // fraction(tp) -> will return the millis part of the second -template -inline ToDuration time_fraction(log_clock::time_point tp) -{ +template +inline ToDuration time_fraction(log_clock::time_point tp) { using std::chrono::duration_cast; using std::chrono::seconds; auto duration = tp.time_since_epoch(); diff --git a/include/spdlog/details/log_msg-inl.h b/include/spdlog/details/log_msg-inl.h index c6e8a7e0..c301b1fa 100644 --- a/include/spdlog/details/log_msg-inl.h +++ b/include/spdlog/details/log_msg-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -12,26 +12,31 @@ namespace spdlog { namespace details { -SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, - spdlog::level::level_enum lvl, spdlog::string_view_t msg) - : logger_name(a_logger_name) - , level(lvl) - , time(log_time) +SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, + spdlog::source_loc loc, + string_view_t a_logger_name, + spdlog::level::level_enum lvl, + spdlog::string_view_t msg) + : logger_name(a_logger_name), + level(lvl), + time(log_time) #ifndef SPDLOG_NO_THREAD_ID - , thread_id(os::thread_id()) + , + thread_id(os::thread_id()) #endif - , source(loc) - , payload(msg) -{} + , + source(loc), + payload(msg) { +} -SPDLOG_INLINE log_msg::log_msg( - spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) - : log_msg(os::now(), loc, a_logger_name, lvl, msg) -{} +SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc, + string_view_t a_logger_name, + spdlog::level::level_enum lvl, + spdlog::string_view_t msg) + : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) - : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) -{} + : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} } // namespace details } // namespace spdlog diff --git a/include/spdlog/details/log_msg.h b/include/spdlog/details/log_msg.h index fed51abd..1833bd7f 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -8,10 +8,13 @@ namespace spdlog { namespace details { -struct SPDLOG_API log_msg -{ +struct SPDLOG_API log_msg { log_msg() = default; - log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); + log_msg(log_clock::time_point log_time, + source_loc loc, + string_view_t logger_name, + level::level_enum lvl, + string_view_t msg); log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); log_msg(const log_msg &other) = default; @@ -33,5 +36,5 @@ struct SPDLOG_API log_msg } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "log_msg-inl.h" + #include "log_msg-inl.h" #endif diff --git a/include/spdlog/details/log_msg_buffer-inl.h b/include/spdlog/details/log_msg_buffer-inl.h index 84d83dc2..fe39b638 100644 --- a/include/spdlog/details/log_msg_buffer-inl.h +++ b/include/spdlog/details/log_msg_buffer-inl.h @@ -4,35 +4,32 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif namespace spdlog { namespace details { SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) - : log_msg{orig_msg} -{ + : log_msg{orig_msg} { buffer.append(logger_name.begin(), logger_name.end()); buffer.append(payload.begin(), payload.end()); update_string_views(); } SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) - : log_msg{other} -{ + : log_msg{other} { buffer.append(logger_name.begin(), logger_name.end()); buffer.append(payload.begin(), payload.end()); update_string_views(); } -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)} -{ +SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, + buffer{std::move(other.buffer)} { update_string_views(); } -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) -{ +SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) { log_msg::operator=(other); buffer.clear(); buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); @@ -40,16 +37,14 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot return *this; } -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT { log_msg::operator=(other); buffer = std::move(other.buffer); update_string_views(); return *this; } -SPDLOG_INLINE void log_msg_buffer::update_string_views() -{ +SPDLOG_INLINE void log_msg_buffer::update_string_views() { logger_name = string_view_t{buffer.data(), logger_name.size()}; payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; } diff --git a/include/spdlog/details/log_msg_buffer.h b/include/spdlog/details/log_msg_buffer.h index 81055065..e5aeeb04 100644 --- a/include/spdlog/details/log_msg_buffer.h +++ b/include/spdlog/details/log_msg_buffer.h @@ -11,8 +11,7 @@ namespace details { // Extend log_msg with internal buffer to store its payload. // This is needed since log_msg holds string_views that points to stack data. -class SPDLOG_API log_msg_buffer : public log_msg -{ +class SPDLOG_API log_msg_buffer : public log_msg { memory_buf_t buffer; void update_string_views(); @@ -29,5 +28,5 @@ public: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "log_msg_buffer-inl.h" + #include "log_msg_buffer-inl.h" #endif diff --git a/include/spdlog/details/mpmc_blocking_q.h b/include/spdlog/details/mpmc_blocking_q.h index deffa6eb..1780284d 100644 --- a/include/spdlog/details/mpmc_blocking_q.h +++ b/include/spdlog/details/mpmc_blocking_q.h @@ -19,19 +19,16 @@ namespace spdlog { namespace details { -template -class mpmc_blocking_queue -{ +template +class mpmc_blocking_queue { public: using item_type = T; explicit mpmc_blocking_queue(size_t max_items) - : q_(max_items) - {} + : q_(max_items) {} #ifndef __MINGW32__ // try to enqueue and block if no room left - void enqueue(T &&item) - { + void enqueue(T &&item) { { std::unique_lock lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); }); @@ -41,8 +38,7 @@ public: } // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) - { + void enqueue_nowait(T &&item) { { std::unique_lock lock(queue_mutex_); q_.push_back(std::move(item)); @@ -50,36 +46,29 @@ public: push_cv_.notify_one(); } - void enqueue_if_have_room(T &&item) - { + void enqueue_if_have_room(T &&item) { bool pushed = false; { std::unique_lock lock(queue_mutex_); - if (!q_.full()) - { + if (!q_.full()) { q_.push_back(std::move(item)); pushed = true; } } - if (pushed) - { + if (pushed) { push_cv_.notify_one(); - } - else - { + } else { ++discard_counter_; } } // dequeue with a timeout. // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) - { + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { { std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { return false; } popped_item = std::move(q_.front()); @@ -90,8 +79,7 @@ public: } // blocking dequeue without a timeout. - void dequeue(T &popped_item) - { + void dequeue(T &popped_item) { { std::unique_lock lock(queue_mutex_); push_cv_.wait(lock, [this] { return !this->q_.empty(); }); @@ -106,8 +94,7 @@ public: // so release the mutex at the very end each function. // try to enqueue and block if no room left - void enqueue(T &&item) - { + void enqueue(T &&item) { std::unique_lock lock(queue_mutex_); pop_cv_.wait(lock, [this] { return !this->q_.full(); }); q_.push_back(std::move(item)); @@ -115,40 +102,32 @@ public: } // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) - { + void enqueue_nowait(T &&item) { std::unique_lock lock(queue_mutex_); q_.push_back(std::move(item)); push_cv_.notify_one(); } - void enqueue_if_have_room(T &&item) - { + void enqueue_if_have_room(T &&item) { bool pushed = false; std::unique_lock lock(queue_mutex_); - if (!q_.full()) - { + if (!q_.full()) { q_.push_back(std::move(item)); pushed = true; } - if (pushed) - { + if (pushed) { push_cv_.notify_one(); - } - else - { + } else { ++discard_counter_; } } // dequeue with a timeout. // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) - { + bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { std::unique_lock lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) - { + if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { return false; } popped_item = std::move(q_.front()); @@ -158,8 +137,7 @@ public: } // blocking dequeue without a timeout. - void dequeue(T &popped_item) - { + void dequeue(T &popped_item) { std::unique_lock lock(queue_mutex_); push_cv_.wait(lock, [this] { return !this->q_.empty(); }); popped_item = std::move(q_.front()); @@ -169,33 +147,24 @@ public: #endif - size_t overrun_counter() - { + size_t overrun_counter() { std::unique_lock lock(queue_mutex_); return q_.overrun_counter(); } - size_t discard_counter() - { - return discard_counter_.load(std::memory_order_relaxed); - } + size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); } - size_t size() - { + size_t size() { std::unique_lock lock(queue_mutex_); return q_.size(); } - void reset_overrun_counter() - { + void reset_overrun_counter() { std::unique_lock lock(queue_mutex_); q_.reset_overrun_counter(); } - void reset_discard_counter() - { - discard_counter_.store(0, std::memory_order_relaxed); - } + void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); } private: std::mutex queue_mutex_; diff --git a/include/spdlog/details/null_mutex.h b/include/spdlog/details/null_mutex.h index 6550a7bf..1d59f82d 100644 --- a/include/spdlog/details/null_mutex.h +++ b/include/spdlog/details/null_mutex.h @@ -9,33 +9,23 @@ namespace spdlog { namespace details { -struct null_mutex -{ +struct null_mutex { void lock() const {} void unlock() const {} }; -struct null_atomic_int -{ +struct null_atomic_int { int value; null_atomic_int() = default; explicit null_atomic_int(int new_value) - : value(new_value) - {} + : value(new_value) {} - int load(std::memory_order = std::memory_order_relaxed) const - { - return value; - } + int load(std::memory_order = std::memory_order_relaxed) const { return value; } - void store(int new_value, std::memory_order = std::memory_order_relaxed) - { - value = new_value; - } + void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } - int exchange(int new_value, std::memory_order = std::memory_order_relaxed) - { + int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { std::swap(new_value, value); return new_value; // return value before the call } diff --git a/include/spdlog/details/os-inl.h b/include/spdlog/details/os-inl.h index ea8864ea..7027e531 100644 --- a/include/spdlog/details/os-inl.h +++ b/include/spdlog/details/os-inl.h @@ -4,91 +4,90 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include #include +#include #include #include #include #include #include #include -#include -#include #include #include +#include #ifdef _WIN32 -# include // for _get_osfhandle, _isatty, _fileno -# include // for _get_pid -# include -# include // for FlushFileBuffers + #include // for FlushFileBuffers + #include // for _get_osfhandle, _isatty, _fileno + #include // for _get_pid + #include -# ifdef __MINGW32__ -# include -# endif + #ifdef __MINGW32__ + #include + #endif -# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) -# include -# include -# endif + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) + #include + #include + #endif -# include // for _mkdir/_wmkdir + #include // for _mkdir/_wmkdir #else // unix -# include -# include + #include + #include -# ifdef __linux__ -# include //Use gettid() syscall under linux to get thread id + #ifdef __linux__ + #include //Use gettid() syscall under linux to get thread id -# elif defined(_AIX) -# include // for pthread_getthrds_np + #elif defined(_AIX) + #include // for pthread_getthrds_np -# elif defined(__DragonFly__) || defined(__FreeBSD__) -# include // for pthread_getthreadid_np + #elif defined(__DragonFly__) || defined(__FreeBSD__) + #include // for pthread_getthreadid_np -# elif defined(__NetBSD__) -# include // for _lwp_self + #elif defined(__NetBSD__) + #include // for _lwp_self -# elif defined(__sun) -# include // for thr_self -# endif + #elif defined(__sun) + #include // for thr_self + #endif #endif // unix #if defined __APPLE__ -# include + #include #endif #ifndef __has_feature // Clang - feature checking macros. -# define __has_feature(x) 0 // Compatibility with non-clang compilers. + #define __has_feature(x) 0 // Compatibility with non-clang compilers. #endif namespace spdlog { namespace details { namespace os { -SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT { #if defined __linux__ && defined SPDLOG_CLOCK_COARSE timespec ts; ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); return std::chrono::time_point( - std::chrono::duration_cast(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); + std::chrono::duration_cast(std::chrono::seconds(ts.tv_sec) + + std::chrono::nanoseconds(ts.tv_nsec))); #else return log_clock::now(); #endif } -SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 std::tm tm; @@ -100,14 +99,12 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT return tm; } -SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT { std::time_t now_t = ::time(nullptr); return localtime(now_t); } -SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { #ifdef _WIN32 std::tm tm; @@ -119,55 +116,48 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT return tm; } -SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT { std::time_t now_t = ::time(nullptr); return gmtime(now_t); } // fopen_s on non windows for writing -SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) -{ +SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) { #ifdef _WIN32 -# ifdef SPDLOG_WCHAR_FILENAMES + #ifdef SPDLOG_WCHAR_FILENAMES *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); -# else + #else *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); -# endif -# if defined(SPDLOG_PREVENT_CHILD_FD) - if (*fp != nullptr) - { + #endif + #if defined(SPDLOG_PREVENT_CHILD_FD) + if (*fp != nullptr) { auto file_handle = reinterpret_cast(_get_osfhandle(::_fileno(*fp))); - if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) - { + if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) { ::fclose(*fp); *fp = nullptr; } } -# endif + #endif #else // unix -# if defined(SPDLOG_PREVENT_CHILD_FD) + #if defined(SPDLOG_PREVENT_CHILD_FD) const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); - if (fd == -1) - { + if (fd == -1) { return true; } *fp = ::fdopen(fd, mode.c_str()); - if (*fp == nullptr) - { + if (*fp == nullptr) { ::close(fd); } -# else + #else *fp = ::fopen((filename.c_str()), mode.c_str()); -# endif + #endif #endif return *fp == nullptr; } -SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wremove(filename.c_str()); #else @@ -175,13 +165,11 @@ SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT #endif } -SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT { return path_exists(filename) ? remove(filename) : 0; } -SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wrename(filename1.c_str(), filename2.c_str()); #else @@ -190,14 +178,13 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename } // Return true if path exists (file or directory) -SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT { #ifdef _WIN32 -# ifdef SPDLOG_WCHAR_FILENAMES + #ifdef SPDLOG_WCHAR_FILENAMES auto attribs = ::GetFileAttributesW(filename.c_str()); -# else + #else auto attribs = ::GetFileAttributesA(filename.c_str()); -# endif + #endif return attribs != INVALID_FILE_ATTRIBUTES; #else // common linux/unix all have the stat system call struct stat buffer; @@ -206,99 +193,89 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT } #ifdef _MSC_VER -// avoid warning about unreachable statement at the end of filesize() -# pragma warning(push) -# pragma warning(disable : 4702) + // avoid warning about unreachable statement at the end of filesize() + #pragma warning(push) + #pragma warning(disable : 4702) #endif // Return file size according to open FILE* object -SPDLOG_INLINE size_t filesize(FILE *f) -{ - if (f == nullptr) - { +SPDLOG_INLINE size_t filesize(FILE *f) { + if (f == nullptr) { throw_spdlog_ex("Failed getting file size. fd is null"); } #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) - { + if (ret >= 0) { return static_cast(ret); } -# else // windows 32 bits + #else // windows 32 bits long ret = ::_filelength(fd); - if (ret >= 0) - { + if (ret >= 0) { return static_cast(ret); } -# endif + #endif #else // unix -// OpenBSD and AIX doesn't compile with :: before the fileno(..) -# if defined(__OpenBSD__) || defined(_AIX) + // OpenBSD and AIX doesn't compile with :: before the fileno(..) + #if defined(__OpenBSD__) || defined(_AIX) int fd = fileno(f); -# else + #else int fd = ::fileno(f); -# endif -// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) -# if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64)) + #endif + // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) + #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \ + (defined(__LP64__) || defined(_LP64)) struct stat64 st; - if (::fstat64(fd, &st) == 0) - { + 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) - { + if (::fstat(fd, &st) == 0) { return static_cast(st.st_size); } -# endif + #endif #endif throw_spdlog_ex("Failed getting file size from fd", errno); return 0; // will not be reached. } #ifdef _MSC_VER -# pragma warning(pop) + #pragma warning(pop) #endif // Return utc offset in minutes or throw spdlog_ex on failure -SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) -{ +SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { #ifdef _WIN32 -# if _WIN32_WINNT < _WIN32_WINNT_WS08 + #if _WIN32_WINNT < _WIN32_WINNT_WS08 TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetTimeZoneInformation(&tzinfo); -# else + #else DYNAMIC_TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); -# endif + #endif if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); int offset = -tzinfo.Bias; - if (tm.tm_isdst) - { + if (tm.tm_isdst) { offset -= tzinfo.DaylightBias; - } - else - { + } else { offset -= tzinfo.StandardBias; } return offset; #else -# if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ + #if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris - struct helper - { - static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime()) - { + struct helper { + static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), + const std::tm &gmtm = details::os::gmtime()) { int local_year = localtm.tm_year + (1900 - 1); int gmt_year = gmtm.tm_year + (1900 - 1); @@ -323,9 +300,9 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) }; auto offset_seconds = helper::calculate_gmt_offset(tm); -# else + #else auto offset_seconds = tm.tm_gmtoff; -# endif + #endif return static_cast(offset_seconds / 60); #endif @@ -334,14 +311,13 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) // Return current thread id as size_t // It exists because the std::this_thread::get_id() is much slower(especially // under VS 2013) -SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT { #ifdef _WIN32 return static_cast(::GetCurrentThreadId()); #elif defined(__linux__) -# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) -# define SYS_gettid __NR_gettid -# endif + #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) + #define SYS_gettid __NR_gettid + #endif return static_cast(::syscall(SYS_gettid)); #elif defined(_AIX) struct __pthrdsinfo buf; @@ -362,20 +338,17 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT uint64_t tid; // There is no pthread_threadid_np prior to 10.6, and it is not supported on any PPC, // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64. -# if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) + #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) tid = pthread_mach_thread_np(pthread_self()); -# elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 - if (&pthread_threadid_np) - { + #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + if (&pthread_threadid_np) { pthread_threadid_np(nullptr, &tid); - } - else - { + } else { tid = pthread_mach_thread_np(pthread_self()); } -# else + #else pthread_threadid_np(nullptr, &tid); -# endif + #endif return static_cast(tid); #else // Default to standard C++11 (other Unix) return static_cast(std::hash()(std::this_thread::get_id())); @@ -383,8 +356,7 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT } // Return current thread id as size_t (from thread local storage) -SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { #if defined(SPDLOG_NO_TLS) return _thread_id(); #else // cache thread id in tls @@ -395,8 +367,7 @@ SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT // This is avoid msvc issue in sleep_for that happens if the clock changes. // See https://github.com/gabime/spdlog/issues/609 -SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT { #if defined(_WIN32) ::Sleep(milliseconds); #else @@ -406,21 +377,16 @@ SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) -{ +SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { memory_buf_t buf; wstr_to_utf8buf(filename, buf); return SPDLOG_BUF_TO_STRING(buf); } #else -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) -{ - return filename; -} +SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; } #endif -SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT { #ifdef _WIN32 return conditional_static_cast(::GetCurrentProcessId()); @@ -431,29 +397,28 @@ SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT // Determine if the terminal supports colors // Based on: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT { #ifdef _WIN32 return true; #else static const bool result = []() { const char *env_colorterm_p = std::getenv("COLORTERM"); - if (env_colorterm_p != nullptr) - { + if (env_colorterm_p != nullptr) { return true; } - static constexpr std::array terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", - "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; + static constexpr std::array terms = {{"ansi", "color", "console", "cygwin", "gnome", + "konsole", "kterm", "linux", "msys", "putty", "rxvt", + "screen", "vt100", "xterm", "alacritty", "vt102"}}; const char *env_term_p = std::getenv("TERM"); - if (env_term_p == nullptr) - { + if (env_term_p == nullptr) { return false; } - return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; }); + return std::any_of(terms.begin(), terms.end(), + [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; }); }(); return result; @@ -462,8 +427,7 @@ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT { #ifdef _WIN32 return ::_isatty(_fileno(file)) != 0; @@ -473,33 +437,27 @@ SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT } #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) -SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) -{ - if (wstr.size() > static_cast((std::numeric_limits::max)()) / 2 - 1) - { +SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) { + if (wstr.size() > static_cast((std::numeric_limits::max)()) / 2 - 1) { throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); } int wstr_size = static_cast(wstr.size()); - if (wstr_size == 0) - { + if (wstr_size == 0) { target.resize(0); return; } int result_size = static_cast(target.capacity()); - if ((wstr_size + 1) * 2 > result_size) - { + if ((wstr_size + 1) * 2 > result_size) { result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); } - if (result_size > 0) - { + if (result_size > 0) { target.resize(result_size); result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL); - if (result_size > 0) - { + if (result_size > 0) { target.resize(result_size); return; } @@ -508,16 +466,13 @@ SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); } -SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) -{ - if (str.size() > static_cast((std::numeric_limits::max)()) - 1) - { +SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) { + if (str.size() > static_cast((std::numeric_limits::max)()) - 1) { throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); } int str_size = static_cast(str.size()); - if (str_size == 0) - { + if (str_size == 0) { target.resize(0); return; } @@ -525,12 +480,11 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) // find the size to allocate for the result buffer int result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0); - if (result_size > 0) - { + if (result_size > 0) { target.resize(result_size); - result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size); - if (result_size > 0) - { + result_size = + ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size); + if (result_size > 0) { assert(result_size == target.size()); return; } @@ -541,14 +495,13 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) // return true on success -static SPDLOG_INLINE bool mkdir_(const filename_t &path) -{ +static SPDLOG_INLINE bool mkdir_(const filename_t &path) { #ifdef _WIN32 -# ifdef SPDLOG_WCHAR_FILENAMES + #ifdef SPDLOG_WCHAR_FILENAMES return ::_wmkdir(path.c_str()) == 0; -# else + #else return ::_mkdir(path.c_str()) == 0; -# endif + #endif #else return ::mkdir(path.c_str(), mode_t(0755)) == 0; #endif @@ -556,32 +509,26 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path) // create the given directory - and all directories leading to it // return true on success or if the directory already exists -SPDLOG_INLINE bool create_dir(const filename_t &path) -{ - if (path_exists(path)) - { +SPDLOG_INLINE bool create_dir(const filename_t &path) { + if (path_exists(path)) { return true; } - if (path.empty()) - { + if (path.empty()) { return false; } size_t search_offset = 0; - do - { + do { auto token_pos = path.find_first_of(folder_seps_filename, search_offset); // treat the entire path as a folder if no folder separator not found - if (token_pos == filename_t::npos) - { + if (token_pos == filename_t::npos) { token_pos = path.size(); } auto subdir = path.substr(0, token_pos); - if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) - { + if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { return false; // return error if failed creating dir } search_offset = token_pos + 1; @@ -595,24 +542,22 @@ SPDLOG_INLINE bool create_dir(const filename_t &path) // "abc/" => "abc" // "abc" => "" // "abc///" => "abc//" -SPDLOG_INLINE filename_t dir_name(const filename_t &path) -{ +SPDLOG_INLINE filename_t dir_name(const filename_t &path) { auto pos = path.find_last_of(folder_seps_filename); return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; } -std::string SPDLOG_INLINE getenv(const char *field) -{ +std::string SPDLOG_INLINE getenv(const char *field) { #if defined(_MSC_VER) -# if defined(__cplusplus_winrt) + #if defined(__cplusplus_winrt) return std::string{}; // not supported under uwp -# else + #else size_t len = 0; char buf[128]; bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; return ok ? buf : std::string{}; -# endif + #endif #else // revert to getenv char *buf = ::getenv(field); return buf ? buf : std::string{}; @@ -621,8 +566,7 @@ std::string SPDLOG_INLINE getenv(const char *field) // Do fsync by FILE handlerpointer // Return true on success -SPDLOG_INLINE bool fsync(FILE *fp) -{ +SPDLOG_INLINE bool fsync(FILE *fp) { #ifdef _WIN32 return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0; #else diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index 37b00874..52a2a053 100644 --- a/include/spdlog/details/os.h +++ b/include/spdlog/details/os.h @@ -3,8 +3,8 @@ #pragma once -#include #include // std::time_t +#include namespace spdlog { namespace details { @@ -22,22 +22,22 @@ SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT; // eol definition #if !defined(SPDLOG_EOL) -# ifdef _WIN32 -# define SPDLOG_EOL "\r\n" -# else -# define SPDLOG_EOL "\n" -# endif + #ifdef _WIN32 + #define SPDLOG_EOL "\r\n" + #else + #define SPDLOG_EOL "\n" + #endif #endif SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL; // folder separator #if !defined(SPDLOG_FOLDER_SEPS) -# ifdef _WIN32 -# define SPDLOG_FOLDER_SEPS "\\/" -# else -# define SPDLOG_FOLDER_SEPS "/" -# endif + #ifdef _WIN32 + #define SPDLOG_FOLDER_SEPS "\\/" + #else + #define SPDLOG_FOLDER_SEPS "/" + #endif #endif SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; @@ -118,5 +118,5 @@ SPDLOG_API bool fsync(FILE *fp); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "os-inl.h" + #include "os-inl.h" #endif diff --git a/include/spdlog/details/periodic_worker-inl.h b/include/spdlog/details/periodic_worker-inl.h index 520a2b33..a9c9865e 100644 --- a/include/spdlog/details/periodic_worker-inl.h +++ b/include/spdlog/details/periodic_worker-inl.h @@ -4,17 +4,15 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif namespace spdlog { namespace details { // stop the worker thread and join it -SPDLOG_INLINE periodic_worker::~periodic_worker() -{ - if (worker_thread_.joinable()) - { +SPDLOG_INLINE periodic_worker::~periodic_worker() { + if (worker_thread_.joinable()) { { std::lock_guard lock(mutex_); active_ = false; diff --git a/include/spdlog/details/periodic_worker.h b/include/spdlog/details/periodic_worker.h index d7d69b28..c59e156f 100644 --- a/include/spdlog/details/periodic_worker.h +++ b/include/spdlog/details/periodic_worker.h @@ -17,24 +17,19 @@ namespace spdlog { namespace details { -class SPDLOG_API periodic_worker -{ +class SPDLOG_API periodic_worker { public: - template - periodic_worker(const std::function &callback_fun, std::chrono::duration interval) - { + template + periodic_worker(const std::function &callback_fun, std::chrono::duration interval) { active_ = (interval > std::chrono::duration::zero()); - if (!active_) - { + if (!active_) { return; } worker_thread_ = std::thread([this, callback_fun, interval]() { - for (;;) - { + for (;;) { std::unique_lock lock(this->mutex_); - if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) - { + if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { return; // active_ == false, so exit this thread } callback_fun(); @@ -56,5 +51,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "periodic_worker-inl.h" + #include "periodic_worker-inl.h" #endif diff --git a/include/spdlog/details/registry-inl.h b/include/spdlog/details/registry-inl.h index cb1fe84f..ad14d636 100644 --- a/include/spdlog/details/registry-inl.h +++ b/include/spdlog/details/registry-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -13,12 +13,12 @@ #include #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER -// support for the default stdout color logger -# ifdef _WIN32 -# include -# else -# include -# endif + // support for the default stdout color logger + #ifdef _WIN32 + #include + #else + #include + #endif #endif // SPDLOG_DISABLE_DEFAULT_LOGGER #include @@ -31,16 +31,15 @@ namespace spdlog { namespace details { SPDLOG_INLINE registry::registry() - : formatter_(new pattern_formatter()) -{ + : formatter_(new pattern_formatter()) { #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). -# ifdef _WIN32 + #ifdef _WIN32 auto color_sink = std::make_shared(); -# else + #else auto color_sink = std::make_shared(); -# endif + #endif const char *default_logger_name = ""; default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); @@ -51,19 +50,16 @@ SPDLOG_INLINE registry::registry() SPDLOG_INLINE registry::~registry() = default; -SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) -{ +SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); register_logger_(std::move(new_logger)); } -SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) -{ +SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); new_logger->set_formatter(formatter_->clone()); - if (err_handler_) - { + if (err_handler_) { new_logger->set_error_handler(err_handler_); } @@ -74,26 +70,22 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logge new_logger->flush_on(flush_level_); - if (backtrace_n_messages_ > 0) - { + if (backtrace_n_messages_ > 0) { new_logger->enable_backtrace(backtrace_n_messages_); } - if (automatic_registration_) - { + if (automatic_registration_) { register_logger_(std::move(new_logger)); } } -SPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) -{ +SPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) { std::lock_guard lock(logger_map_mutex_); auto found = loggers_.find(logger_name); return found == loggers_.end() ? nullptr : found->second; } -SPDLOG_INLINE std::shared_ptr registry::default_logger() -{ +SPDLOG_INLINE std::shared_ptr registry::default_logger() { std::lock_guard lock(logger_map_mutex_); return default_logger_; } @@ -102,141 +94,113 @@ SPDLOG_INLINE std::shared_ptr registry::default_logger() // To be used directly by the spdlog default api (e.g. spdlog::info) // This make the default API faster, but cannot be used concurrently with set_default_logger(). // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. -SPDLOG_INLINE logger *registry::get_default_raw() -{ - return default_logger_.get(); -} +SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); } // set default logger. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. -SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) -{ +SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) { std::lock_guard lock(logger_map_mutex_); // remove previous default logger from the map - if (default_logger_ != nullptr) - { + if (default_logger_ != nullptr) { loggers_.erase(default_logger_->name()); } - if (new_default_logger != nullptr) - { + if (new_default_logger != nullptr) { loggers_[new_default_logger->name()] = new_default_logger; } default_logger_ = std::move(new_default_logger); } -SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) -{ +SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) { std::lock_guard lock(tp_mutex_); tp_ = std::move(tp); } -SPDLOG_INLINE std::shared_ptr registry::get_tp() -{ +SPDLOG_INLINE std::shared_ptr registry::get_tp() { std::lock_guard lock(tp_mutex_); return tp_; } // Set global formatter. Each sink in each logger will get a clone of this object -SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) -{ +SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) { std::lock_guard lock(logger_map_mutex_); formatter_ = std::move(formatter); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->set_formatter(formatter_->clone()); } } -SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) -{ +SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) { std::lock_guard lock(logger_map_mutex_); backtrace_n_messages_ = n_messages; - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->enable_backtrace(n_messages); } } -SPDLOG_INLINE void registry::disable_backtrace() -{ +SPDLOG_INLINE void registry::disable_backtrace() { std::lock_guard lock(logger_map_mutex_); backtrace_n_messages_ = 0; - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->disable_backtrace(); } } -SPDLOG_INLINE void registry::set_level(level::level_enum log_level) -{ +SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->set_level(log_level); } global_log_level_ = log_level; } -SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) -{ +SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->flush_on(log_level); } flush_level_ = log_level; } -SPDLOG_INLINE void registry::set_error_handler(err_handler handler) -{ +SPDLOG_INLINE void registry::set_error_handler(err_handler handler) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->set_error_handler(handler); } err_handler_ = std::move(handler); } -SPDLOG_INLINE void registry::apply_all(const std::function)> &fun) -{ +SPDLOG_INLINE void registry::apply_all(const std::function)> &fun) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { fun(l.second); } } -SPDLOG_INLINE void registry::flush_all() -{ +SPDLOG_INLINE void registry::flush_all() { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->flush(); } } -SPDLOG_INLINE void registry::drop(const std::string &logger_name) -{ +SPDLOG_INLINE void registry::drop(const std::string &logger_name) { std::lock_guard lock(logger_map_mutex_); auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; loggers_.erase(logger_name); - if (is_default_logger) - { + if (is_default_logger) { default_logger_.reset(); } } -SPDLOG_INLINE void registry::drop_all() -{ +SPDLOG_INLINE void registry::drop_all() { std::lock_guard lock(logger_map_mutex_); loggers_.clear(); default_logger_.reset(); } // clean all resources and threads started by the registry -SPDLOG_INLINE void registry::shutdown() -{ +SPDLOG_INLINE void registry::shutdown() { { std::lock_guard lock(flusher_mutex_); periodic_flusher_.reset(); @@ -250,62 +214,48 @@ SPDLOG_INLINE void registry::shutdown() } } -SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() -{ - return tp_mutex_; -} +SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } -SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) -{ +SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) { std::lock_guard lock(logger_map_mutex_); automatic_registration_ = automatic_registration; } -SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) -{ +SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { std::lock_guard lock(logger_map_mutex_); log_levels_ = std::move(levels); auto global_level_requested = global_level != nullptr; global_log_level_ = global_level_requested ? *global_level : global_log_level_; - for (auto &logger : loggers_) - { + for (auto &logger : loggers_) { auto logger_entry = log_levels_.find(logger.first); - if (logger_entry != log_levels_.end()) - { + if (logger_entry != log_levels_.end()) { logger.second->set_level(logger_entry->second); - } - else if (global_level_requested) - { + } else if (global_level_requested) { logger.second->set_level(*global_level); } } } -SPDLOG_INLINE registry ®istry::instance() -{ +SPDLOG_INLINE registry ®istry::instance() { static registry s_instance; return s_instance; } -SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) -{ +SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); auto it = log_levels_.find(new_logger->name()); auto new_level = it != log_levels_.end() ? it->second : global_log_level_; new_logger->set_level(new_level); } -SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) -{ - if (loggers_.find(logger_name) != loggers_.end()) - { +SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) { + if (loggers_.find(logger_name) != loggers_.end()) { throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); } } -SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) -{ +SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) { auto logger_name = new_logger->name(); throw_if_exists_(logger_name); loggers_[logger_name] = std::move(new_logger); diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 4666fa29..4b8e012d 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -14,9 +14,9 @@ #include #include #include +#include #include #include -#include namespace spdlog { class logger; @@ -24,8 +24,7 @@ class logger; namespace details { class thread_pool; -class SPDLOG_API registry -{ +class SPDLOG_API registry { public: using log_levels = std::unordered_map; registry(const registry &) = delete; @@ -61,9 +60,8 @@ public: void flush_on(level::level_enum log_level); - template - void flush_every(std::chrono::duration interval) - { + template + void flush_every(std::chrono::duration interval) { std::lock_guard lock(flusher_mutex_); auto clbk = [this]() { this->flush_all(); }; periodic_flusher_ = details::make_unique(clbk, interval); @@ -119,5 +117,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "registry-inl.h" + #include "registry-inl.h" #endif diff --git a/include/spdlog/details/synchronous_factory.h b/include/spdlog/details/synchronous_factory.h index e1e42268..21ded285 100644 --- a/include/spdlog/details/synchronous_factory.h +++ b/include/spdlog/details/synchronous_factory.h @@ -10,11 +10,9 @@ namespace spdlog { // Default logger factory- creates synchronous loggers class logger; -struct synchronous_factory -{ - template - static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) - { +struct synchronous_factory { + template + static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { auto sink = std::make_shared(std::forward(args)...); auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); details::registry::instance().initialize_logger(new_logger); diff --git a/include/spdlog/details/tcp_client-windows.h b/include/spdlog/details/tcp_client-windows.h index 968b2570..70bae0e4 100644 --- a/include/spdlog/details/tcp_client-windows.h +++ b/include/spdlog/details/tcp_client-windows.h @@ -8,12 +8,12 @@ #include #include -#include -#include -#include -#include #include +#include #include +#include +#include +#include #pragma comment(lib, "Ws2_32.lib") #pragma comment(lib, "Mswsock.lib") @@ -21,66 +21,48 @@ namespace spdlog { namespace details { -class tcp_client -{ +class tcp_client { SOCKET socket_ = INVALID_SOCKET; - static void init_winsock_() - { + static void init_winsock_() { WSADATA wsaData; auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData); - if (rv != 0) - { + if (rv != 0) { throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); } } - static void throw_winsock_error_(const std::string &msg, int last_error) - { + static void throw_winsock_error_(const std::string &msg, int last_error) { char buf[512]; ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf)); } public: - tcp_client() - { - init_winsock_(); - } + tcp_client() { init_winsock_(); } - ~tcp_client() - { + ~tcp_client() { close(); ::WSACleanup(); } - bool is_connected() const - { - return socket_ != INVALID_SOCKET; - } + bool is_connected() const { return socket_ != INVALID_SOCKET; } - void close() - { + void close() { ::closesocket(socket_); socket_ = INVALID_SOCKET; } - SOCKET fd() const - { - return socket_; - } + SOCKET fd() const { return socket_; } // try to connect or throw on failure - void connect(const std::string &host, int port) - { - if (is_connected()) - { + void connect(const std::string &host, int port) { + if (is_connected()) { close(); } - struct addrinfo hints - {}; + struct addrinfo hints {}; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on @@ -92,8 +74,7 @@ public: struct addrinfo *addrinfo_result; auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); int last_error = 0; - if (rv != 0) - { + if (rv != 0) { last_error = ::WSAGetLastError(); WSACleanup(); throw_winsock_error_("getaddrinfo failed", last_error); @@ -101,28 +82,22 @@ public: // Try each address until we successfully connect(2). - for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) - { + for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); - if (socket_ == INVALID_SOCKET) - { + if (socket_ == INVALID_SOCKET) { last_error = ::WSAGetLastError(); WSACleanup(); continue; } - if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) - { + if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) { break; - } - else - { + } else { last_error = ::WSAGetLastError(); close(); } } ::freeaddrinfo(addrinfo_result); - if (socket_ == INVALID_SOCKET) - { + if (socket_ == INVALID_SOCKET) { WSACleanup(); throw_winsock_error_("connect failed", last_error); } @@ -134,15 +109,12 @@ public: // Send exactly n_bytes of the given data. // On error close the connection and throw. - void send(const char *data, size_t n_bytes) - { + void send(const char *data, size_t n_bytes) { size_t bytes_sent = 0; - while (bytes_sent < n_bytes) - { + while (bytes_sent < n_bytes) { const int send_flags = 0; auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags); - if (write_result == SOCKET_ERROR) - { + if (write_result == SOCKET_ERROR) { int last_error = ::WSAGetLastError(); close(); throw_winsock_error_("send failed", last_error); diff --git a/include/spdlog/details/tcp_client.h b/include/spdlog/details/tcp_client.h index 8b11dfd2..437bbf18 100644 --- a/include/spdlog/details/tcp_client.h +++ b/include/spdlog/details/tcp_client.h @@ -4,59 +4,45 @@ #pragma once #ifdef _WIN32 -# error include tcp_client-windows.h instead + #error include tcp_client-windows.h instead #endif // tcp client helper #include #include -#include #include -#include #include -#include #include +#include +#include +#include #include namespace spdlog { namespace details { -class tcp_client -{ +class tcp_client { int socket_ = -1; public: - bool is_connected() const - { - return socket_ != -1; - } + bool is_connected() const { return socket_ != -1; } - void close() - { - if (is_connected()) - { + void close() { + if (is_connected()) { ::close(socket_); socket_ = -1; } } - int fd() const - { - return socket_; - } + int fd() const { return socket_; } - ~tcp_client() - { - close(); - } + ~tcp_client() { close(); } // try to connect or throw on failure - void connect(const std::string &host, int port) - { + void connect(const std::string &host, int port) { close(); - struct addrinfo hints - {}; + 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 @@ -66,29 +52,25 @@ public: auto port_str = std::to_string(port); struct addrinfo *addrinfo_result; auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result); - if (rv != 0) - { + if (rv != 0) { throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv))); } // Try each address until we successfully connect(2). int last_errno = 0; - for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) - { + for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) { #if defined(SOCK_CLOEXEC) const int flags = SOCK_CLOEXEC; #else const int flags = 0; #endif socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol); - if (socket_ == -1) - { + if (socket_ == -1) { last_errno = errno; continue; } rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen); - if (rv == 0) - { + if (rv == 0) { break; } last_errno = errno; @@ -96,8 +78,7 @@ public: socket_ = -1; } ::freeaddrinfo(addrinfo_result); - if (socket_ == -1) - { + if (socket_ == -1) { throw_spdlog_ex("::connect failed", last_errno); } @@ -111,25 +92,22 @@ public: #endif #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL) -# error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" + #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available" #endif } // Send exactly n_bytes of the given data. // On error close the connection and throw. - void send(const char *data, size_t n_bytes) - { + void send(const char *data, size_t n_bytes) { size_t bytes_sent = 0; - while (bytes_sent < n_bytes) - { + while (bytes_sent < n_bytes) { #if defined(MSG_NOSIGNAL) const int send_flags = MSG_NOSIGNAL; #else const int send_flags = 0; #endif auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags); - if (write_result < 0) - { + if (write_result < 0) { close(); throw_spdlog_ex("write(2) failed", errno); } diff --git a/include/spdlog/details/thread_pool-inl.h b/include/spdlog/details/thread_pool-inl.h index d3ae442f..afc20eb2 100644 --- a/include/spdlog/details/thread_pool-inl.h +++ b/include/spdlog/details/thread_pool-inl.h @@ -4,26 +4,25 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include +#include namespace spdlog { namespace details { -SPDLOG_INLINE thread_pool::thread_pool( - size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop) - : q_(q_max_items) -{ - if (threads_n == 0 || threads_n > 1000) - { +SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, + size_t threads_n, + std::function on_thread_start, + 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)"); } - for (size_t i = 0; i < threads_n; i++) - { + for (size_t i = 0; i < threads_n; i++) { threads_.emplace_back([this, on_thread_start, on_thread_stop] { on_thread_start(); this->thread_pool::worker_loop_(); @@ -33,100 +32,71 @@ SPDLOG_INLINE thread_pool::thread_pool( } SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start) - : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) -{} + : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {} SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) : thread_pool( - q_max_items, threads_n, [] {}, [] {}) -{} + q_max_items, threads_n, [] {}, [] {}) {} // message all threads to terminate gracefully join them -SPDLOG_INLINE thread_pool::~thread_pool() -{ - SPDLOG_TRY - { - for (size_t i = 0; i < threads_.size(); i++) - { +SPDLOG_INLINE thread_pool::~thread_pool() { + SPDLOG_TRY { + for (size_t i = 0; i < threads_.size(); i++) { post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); } - for (auto &t : threads_) - { + for (auto &t : threads_) { t.join(); } } SPDLOG_CATCH_STD } -void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) -{ +void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, + const details::log_msg &msg, + async_overflow_policy overflow_policy) { async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); post_async_msg_(std::move(async_m), overflow_policy); } -void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) -{ +void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) { post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); } -size_t SPDLOG_INLINE thread_pool::overrun_counter() -{ - return q_.overrun_counter(); -} +size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); } -void SPDLOG_INLINE thread_pool::reset_overrun_counter() -{ - q_.reset_overrun_counter(); -} +void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } -size_t SPDLOG_INLINE thread_pool::discard_counter() -{ - return q_.discard_counter(); -} +size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); } -void SPDLOG_INLINE thread_pool::reset_discard_counter() -{ - q_.reset_discard_counter(); -} +void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } -size_t SPDLOG_INLINE thread_pool::queue_size() -{ - return q_.size(); -} +size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); } -void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) -{ - if (overflow_policy == async_overflow_policy::block) - { +void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) { + if (overflow_policy == async_overflow_policy::block) { q_.enqueue(std::move(new_msg)); - } - else if (overflow_policy == async_overflow_policy::overrun_oldest) - { + } else if (overflow_policy == async_overflow_policy::overrun_oldest) { q_.enqueue_nowait(std::move(new_msg)); - } - else - { + } else { assert(overflow_policy == async_overflow_policy::discard_new); q_.enqueue_if_have_room(std::move(new_msg)); } } -void SPDLOG_INLINE thread_pool::worker_loop_() -{ - while (process_next_msg_()) {} +void SPDLOG_INLINE thread_pool::worker_loop_() { + while (process_next_msg_()) { + } } // process next message in the queue // return true if this thread should still be active (while no terminate msg // was received) -bool SPDLOG_INLINE thread_pool::process_next_msg_() -{ +bool SPDLOG_INLINE thread_pool::process_next_msg_() { async_msg incoming_async_msg; q_.dequeue(incoming_async_msg); - switch (incoming_async_msg.msg_type) - { + switch (incoming_async_msg.msg_type) { case async_msg_type::log: { incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); return true; diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h index 3d0b2cb3..1c17b4ac 100644 --- a/include/spdlog/details/thread_pool.h +++ b/include/spdlog/details/thread_pool.h @@ -8,10 +8,10 @@ #include #include +#include #include #include #include -#include namespace spdlog { class async_logger; @@ -20,17 +20,11 @@ namespace details { using async_logger_ptr = std::shared_ptr; -enum class async_msg_type -{ - log, - flush, - terminate -}; +enum class async_msg_type { log, flush, terminate }; // Async msg to move to/from the queue // Movable only. should never be copied -struct async_msg : log_msg_buffer -{ +struct async_msg : log_msg_buffer { async_msg_type msg_type{async_msg_type::log}; async_logger_ptr worker_ptr; @@ -43,13 +37,11 @@ struct async_msg : log_msg_buffer // support for vs2013 move #if defined(_MSC_VER) && _MSC_VER <= 1800 async_msg(async_msg &&other) - : log_msg_buffer(std::move(other)) - , msg_type(other.msg_type) - , worker_ptr(std::move(other.worker_ptr)) - {} + : log_msg_buffer(std::move(other)), + msg_type(other.msg_type), + worker_ptr(std::move(other.worker_ptr)) {} - async_msg &operator=(async_msg &&other) - { + async_msg &operator=(async_msg &&other) { *static_cast(this) = std::move(other); msg_type = other.msg_type; worker_ptr = std::move(other.worker_ptr); @@ -62,29 +54,28 @@ struct async_msg : log_msg_buffer // construct from log_msg with given type async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m) - : log_msg_buffer{m} - , msg_type{the_type} - , worker_ptr{std::move(worker)} - {} + : log_msg_buffer{m}, + msg_type{the_type}, + worker_ptr{std::move(worker)} {} async_msg(async_logger_ptr &&worker, async_msg_type the_type) - : log_msg_buffer{} - , msg_type{the_type} - , worker_ptr{std::move(worker)} - {} + : log_msg_buffer{}, + msg_type{the_type}, + worker_ptr{std::move(worker)} {} explicit async_msg(async_msg_type the_type) - : async_msg{nullptr, the_type} - {} + : async_msg{nullptr, the_type} {} }; -class SPDLOG_API thread_pool -{ +class SPDLOG_API thread_pool { public: using item_type = async_msg; using q_type = details::mpmc_blocking_queue; - thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start, std::function on_thread_stop); + thread_pool(size_t q_max_items, + size_t threads_n, + std::function on_thread_start, + std::function on_thread_stop); thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start); thread_pool(size_t q_max_items, size_t threads_n); @@ -120,5 +111,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "thread_pool-inl.h" + #include "thread_pool-inl.h" #endif diff --git a/include/spdlog/details/udp_client-windows.h b/include/spdlog/details/udp_client-windows.h index 10894ee6..9def2b46 100644 --- a/include/spdlog/details/udp_client-windows.h +++ b/include/spdlog/details/udp_client-windows.h @@ -9,49 +9,43 @@ #include #include #include +#include +#include +#include #include #include -#include -#include -#include #if defined(_MSC_VER) -# pragma comment(lib, "Ws2_32.lib") -# pragma comment(lib, "Mswsock.lib") -# pragma comment(lib, "AdvApi32.lib") + #pragma comment(lib, "Ws2_32.lib") + #pragma comment(lib, "Mswsock.lib") + #pragma comment(lib, "AdvApi32.lib") #endif namespace spdlog { namespace details { -class udp_client -{ +class udp_client { static constexpr int TX_BUFFER_SIZE = 1024 * 10; SOCKET socket_ = INVALID_SOCKET; sockaddr_in addr_ = {}; - static void init_winsock_() - { + static void init_winsock_() { WSADATA wsaData; auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData); - if (rv != 0) - { + if (rv != 0) { throw_winsock_error_("WSAStartup failed", ::WSAGetLastError()); } } - static void throw_winsock_error_(const std::string &msg, int last_error) - { + static void throw_winsock_error_(const std::string &msg, int last_error) { char buf[512]; ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL); throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf)); } - void cleanup_() - { - if (socket_ != INVALID_SOCKET) - { + void cleanup_() { + if (socket_ != INVALID_SOCKET) { ::closesocket(socket_); } socket_ = INVALID_SOCKET; @@ -59,52 +53,41 @@ class udp_client } public: - udp_client(const std::string &host, uint16_t port) - { + udp_client(const std::string &host, uint16_t port) { init_winsock_(); addr_.sin_family = PF_INET; addr_.sin_port = htons(port); addr_.sin_addr.s_addr = INADDR_ANY; - if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) - { + if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1) { int last_error = ::WSAGetLastError(); ::WSACleanup(); throw_winsock_error_("error: Invalid address!", last_error); } socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); - if (socket_ == INVALID_SOCKET) - { + if (socket_ == INVALID_SOCKET) { int last_error = ::WSAGetLastError(); ::WSACleanup(); throw_winsock_error_("error: Create Socket failed", last_error); } int option_value = TX_BUFFER_SIZE; - if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) - { + if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), + sizeof(option_value)) < 0) { int last_error = ::WSAGetLastError(); cleanup_(); throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error); } } - ~udp_client() - { - cleanup_(); - } + ~udp_client() { cleanup_(); } - SOCKET fd() const - { - return socket_; - } + SOCKET fd() const { return socket_; } - void send(const char *data, size_t n_bytes) - { + void send(const char *data, size_t n_bytes) { socklen_t tolen = sizeof(struct sockaddr); - if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1) - { + if (::sendto(socket_, data, static_cast(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1) { throw_spdlog_ex("sendto(2) failed", errno); } } diff --git a/include/spdlog/details/udp_client.h b/include/spdlog/details/udp_client.h index e8c2cccf..6cf4b4a4 100644 --- a/include/spdlog/details/udp_client.h +++ b/include/spdlog/details/udp_client.h @@ -7,51 +7,46 @@ // Will throw on construction if the socket creation failed. #ifdef _WIN32 -# error "include udp_client-windows.h instead" + #error "include udp_client-windows.h instead" #endif +#include +#include +#include +#include +#include #include #include -#include #include -#include -#include #include -#include -#include #include namespace spdlog { namespace details { -class udp_client -{ +class udp_client { static constexpr int TX_BUFFER_SIZE = 1024 * 10; int socket_ = -1; struct sockaddr_in sockAddr_; - void cleanup_() - { - if (socket_ != -1) - { + void cleanup_() { + if (socket_ != -1) { ::close(socket_); socket_ = -1; } } public: - udp_client(const std::string &host, uint16_t port) - { + udp_client(const std::string &host, uint16_t port) { socket_ = ::socket(PF_INET, SOCK_DGRAM, 0); - if (socket_ < 0) - { + if (socket_ < 0) { throw_spdlog_ex("error: Create Socket Failed!"); } int option_value = TX_BUFFER_SIZE; - if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), sizeof(option_value)) < 0) - { + if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&option_value), + sizeof(option_value)) < 0) { cleanup_(); throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!"); } @@ -59,8 +54,7 @@ public: sockAddr_.sin_family = AF_INET; sockAddr_.sin_port = htons(port); - if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) - { + if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) { cleanup_(); throw_spdlog_ex("error: Invalid address!"); } @@ -68,24 +62,16 @@ public: ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero)); } - ~udp_client() - { - cleanup_(); - } + ~udp_client() { cleanup_(); } - int fd() const - { - return socket_; - } + int fd() const { return socket_; } // Send exactly n_bytes of the given data. // On error close the connection and throw. - void send(const char *data, size_t n_bytes) - { + void send(const char *data, size_t n_bytes) { ssize_t toslen = 0; socklen_t tolen = sizeof(struct sockaddr); - if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1) - { + if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1) { throw_spdlog_ex("sendto(2) failed", errno); } } diff --git a/include/spdlog/details/windows_include.h b/include/spdlog/details/windows_include.h index a92390b9..43b8958d 100644 --- a/include/spdlog/details/windows_include.h +++ b/include/spdlog/details/windows_include.h @@ -1,11 +1,11 @@ #pragma once #ifndef NOMINMAX -# define NOMINMAX // prevent windows redefining min/max + #define NOMINMAX // prevent windows redefining min/max #endif #ifndef WIN32_LEAN_AND_MEAN -# define WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN #endif #include diff --git a/include/spdlog/fmt/bin_to_hex.h b/include/spdlog/fmt/bin_to_hex.h index 3bf003d4..9345abe3 100644 --- a/include/spdlog/fmt/bin_to_hex.h +++ b/include/spdlog/fmt/bin_to_hex.h @@ -9,13 +9,13 @@ #include #if defined(__has_include) -# if __has_include() -# include -# endif + #if __has_include() + #include + #endif #endif #if __cpp_lib_span >= 202002L -# include + #include #endif // @@ -39,29 +39,18 @@ namespace spdlog { namespace details { -template -class dump_info -{ +template +class dump_info { public: dump_info(It range_begin, It range_end, size_t size_per_line) - : begin_(range_begin) - , end_(range_end) - , size_per_line_(size_per_line) - {} + : begin_(range_begin), + end_(range_end), + size_per_line_(size_per_line) {} // do not use begin() and end() to avoid collision with fmt/ranges - It get_begin() const - { - return begin_; - } - It get_end() const - { - return end_; - } - size_t size_per_line() const - { - return size_per_line_; - } + It get_begin() const { return begin_; } + It get_end() const { return end_; } + size_t size_per_line() const { return size_per_line_; } private: It begin_, end_; @@ -70,9 +59,9 @@ private: } // namespace details // create a dump_info that wraps the given container -template -inline details::dump_info to_hex(const Container &container, size_t size_per_line = 32) -{ +template +inline details::dump_info to_hex(const Container &container, + size_t size_per_line = 32) { static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1"); using Iter = typename Container::const_iterator; return details::dump_info(std::begin(container), std::end(container), size_per_line); @@ -80,10 +69,9 @@ 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) -{ +template +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"); using Iter = typename Container::iterator; @@ -93,9 +81,8 @@ inline details::dump_info::iterator> to_hex( #endif // 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) -{ +template +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); } @@ -109,9 +96,8 @@ namespace #endif { -template -struct formatter, char> -{ +template +struct formatter, char> { const char delimiter = ' '; bool put_newlines = true; bool put_delimiters = true; @@ -120,14 +106,11 @@ struct formatter, char> bool show_ascii = false; // parse the format string flags - template - SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { + template + SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { auto it = ctx.begin(); - while (it != ctx.end() && *it != '}') - { - switch (*it) - { + while (it != ctx.end() && *it != '}') { + switch (*it) { case 'X': use_uppercase = true; break; @@ -142,8 +125,7 @@ struct formatter, char> show_ascii = false; break; case 'a': - if (put_newlines) - { + if (put_newlines) { show_ascii = true; } break; @@ -155,9 +137,9 @@ struct formatter, char> } // format the given bytes range as hex - template - auto format(const spdlog::details::dump_info &the_range, FormatContext &ctx) const -> decltype(ctx.out()) - { + template + auto format(const spdlog::details::dump_info &the_range, FormatContext &ctx) const + -> decltype(ctx.out()) { SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; const char *hex_chars = use_uppercase ? hex_upper : hex_lower; @@ -170,18 +152,14 @@ struct formatter, char> int size_per_line = static_cast(the_range.size_per_line()); auto start_of_line = the_range.get_begin(); - for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) - { + for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) { auto ch = static_cast(*i); - if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line)) - { - if (show_ascii && i != the_range.get_begin()) - { + if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line)) { + if (show_ascii && i != the_range.get_begin()) { *inserter++ = delimiter; *inserter++ = delimiter; - for (auto j = start_of_line; j < i; j++) - { + for (auto j = start_of_line; j < i; j++) { auto pc = static_cast(*j); *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; } @@ -196,8 +174,7 @@ struct formatter, char> continue; } - if (put_delimiters && i != the_range.get_begin()) - { + if (put_delimiters && i != the_range.get_begin()) { *inserter++ = delimiter; } @@ -206,23 +183,19 @@ struct formatter, char> } if (show_ascii) // add ascii to last line { - if (the_range.get_end() - the_range.get_begin() > size_per_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); - while (blank_num-- > 0) - { + while (blank_num-- > 0) { *inserter++ = delimiter; *inserter++ = delimiter; - if (put_delimiters) - { + if (put_delimiters) { *inserter++ = delimiter; } } } *inserter++ = delimiter; *inserter++ = delimiter; - for (auto j = start_of_line; j != the_range.get_end(); j++) - { + for (auto j = start_of_line; j != the_range.get_end(); j++) { auto pc = static_cast(*j); *inserter++ = std::isprint(pc) ? static_cast(*j) : '.'; } @@ -231,16 +204,14 @@ struct formatter, char> } // put newline(and position header) - template - void put_newline(It inserter, std::size_t pos) const - { + template + void put_newline(It inserter, std::size_t pos) const { #ifdef _WIN32 *inserter++ = '\r'; #endif *inserter++ = '\n'; - if (put_positions) - { + if (put_positions) { spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); } } diff --git a/include/spdlog/fmt/chrono.h b/include/spdlog/fmt/chrono.h index 83fad2ff..2959890c 100644 --- a/include/spdlog/fmt/chrono.h +++ b/include/spdlog/fmt/chrono.h @@ -9,14 +9,14 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/compile.h b/include/spdlog/fmt/compile.h index 906e9f57..6a01489a 100644 --- a/include/spdlog/fmt/compile.h +++ b/include/spdlog/fmt/compile.h @@ -9,14 +9,14 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/fmt.h b/include/spdlog/fmt/fmt.h index 90fcae0f..596e68c9 100644 --- a/include/spdlog/fmt/fmt.h +++ b/include/spdlog/fmt/fmt.h @@ -11,23 +11,23 @@ // #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format -# include + #include #elif !defined(SPDLOG_FMT_EXTERNAL) -# if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) -# define FMT_HEADER_ONLY -# endif -# ifndef FMT_USE_WINDOWS_H -# define FMT_USE_WINDOWS_H 0 -# endif -// enable the 'n' flag in for backward compatibility with fmt 6.x -# define FMT_DEPRECATED_N_SPECIFIER -// enable ostream formatting for backward compatibility with fmt 8.x -# define FMT_DEPRECATED_OSTREAM + #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) + #define FMT_HEADER_ONLY + #endif + #ifndef FMT_USE_WINDOWS_H + #define FMT_USE_WINDOWS_H 0 + #endif + // enable the 'n' flag in for backward compatibility with fmt 6.x + #define FMT_DEPRECATED_N_SPECIFIER + // enable ostream formatting for backward compatibility with fmt 8.x + #define FMT_DEPRECATED_OSTREAM -# include -# include + #include + #include #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib -# include -# include + #include + #include #endif diff --git a/include/spdlog/fmt/ostr.h b/include/spdlog/fmt/ostr.h index 75880341..40202b51 100644 --- a/include/spdlog/fmt/ostr.h +++ b/include/spdlog/fmt/ostr.h @@ -9,14 +9,14 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/ranges.h b/include/spdlog/fmt/ranges.h index 9103a5f6..684476bd 100644 --- a/include/spdlog/fmt/ranges.h +++ b/include/spdlog/fmt/ranges.h @@ -9,14 +9,14 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/std.h b/include/spdlog/fmt/std.h index 0490cab0..8891f031 100644 --- a/include/spdlog/fmt/std.h +++ b/include/spdlog/fmt/std.h @@ -5,19 +5,19 @@ #pragma once // -// include bundled or external copy of fmtlib's std support (for formatting e.g. std::filesystem::path, std::thread::id, std::monostate, -// std::variant, ...) +// include bundled or external copy of fmtlib's std support (for formatting e.g. std::filesystem::path, std::thread::id, +// std::monostate, std::variant, ...) // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/xchar.h b/include/spdlog/fmt/xchar.h index 9a766e5a..87408d25 100644 --- a/include/spdlog/fmt/xchar.h +++ b/include/spdlog/fmt/xchar.h @@ -9,14 +9,14 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# ifdef SPDLOG_HEADER_ONLY -# ifndef FMT_HEADER_ONLY -# define FMT_HEADER_ONLY -# endif -# endif -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #ifdef SPDLOG_HEADER_ONLY + #ifndef FMT_HEADER_ONLY + #define FMT_HEADER_ONLY + #endif + #endif + #include + #else + #include + #endif #endif diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h index 5086fb21..7fbd52a5 100644 --- a/include/spdlog/formatter.h +++ b/include/spdlog/formatter.h @@ -3,13 +3,12 @@ #pragma once -#include #include +#include namespace spdlog { -class formatter -{ +class formatter { public: virtual ~formatter() = default; virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; diff --git a/include/spdlog/logger-inl.h b/include/spdlog/logger-inl.h index 227cec43..5c796e88 100644 --- a/include/spdlog/logger-inl.h +++ b/include/spdlog/logger-inl.h @@ -4,12 +4,12 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include #include +#include #include @@ -17,31 +17,29 @@ namespace spdlog { // public methods SPDLOG_INLINE logger::logger(const logger &other) - : name_(other.name_) - , sinks_(other.sinks_) - , level_(other.level_.load(std::memory_order_relaxed)) - , flush_level_(other.flush_level_.load(std::memory_order_relaxed)) - , custom_err_handler_(other.custom_err_handler_) - , tracer_(other.tracer_) -{} + : name_(other.name_), + sinks_(other.sinks_), + level_(other.level_.load(std::memory_order_relaxed)), + flush_level_(other.flush_level_.load(std::memory_order_relaxed)), + custom_err_handler_(other.custom_err_handler_), + tracer_(other.tracer_) {} -SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)), - sinks_(std::move(other.sinks_)), - level_(other.level_.load(std::memory_order_relaxed)), - flush_level_(other.flush_level_.load(std::memory_order_relaxed)), - custom_err_handler_(std::move(other.custom_err_handler_)), - tracer_(std::move(other.tracer_)) +SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT + : name_(std::move(other.name_)), + sinks_(std::move(other.sinks_)), + level_(other.level_.load(std::memory_order_relaxed)), + flush_level_(other.flush_level_.load(std::memory_order_relaxed)), + custom_err_handler_(std::move(other.custom_err_handler_)), + tracer_(std::move(other.tracer_)) {} -SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT { this->swap(other); return *this; } -SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT -{ +SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT { name_.swap(other.name_); sinks_.swap(other.sinks_); @@ -59,179 +57,115 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT std::swap(tracer_, other.tracer_); } -SPDLOG_INLINE void swap(logger &a, logger &b) -{ - a.swap(b); -} +SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); } -SPDLOG_INLINE void logger::set_level(level::level_enum log_level) -{ - level_.store(log_level); -} +SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); } -SPDLOG_INLINE level::level_enum logger::level() const -{ +SPDLOG_INLINE level::level_enum logger::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } -SPDLOG_INLINE const std::string &logger::name() const -{ - return name_; -} +SPDLOG_INLINE const std::string &logger::name() const { return name_; } // set formatting for the sinks in this logger. // each sink will get a separate instance of the formatter object. -SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) -{ - for (auto it = sinks_.begin(); it != sinks_.end(); ++it) - { - if (std::next(it) == sinks_.end()) - { +SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) { + for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { + 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 - } - else - { + } else { (*it)->set_formatter(f->clone()); } } } -SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) -{ +SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) { auto new_formatter = details::make_unique(std::move(pattern), time_type); set_formatter(std::move(new_formatter)); } // create new backtrace sink and move to it all our child sinks -SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) -{ - tracer_.enable(n_messages); -} +SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); } // restore orig sinks and level and delete the backtrace sink -SPDLOG_INLINE void logger::disable_backtrace() -{ - tracer_.disable(); -} +SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); } -SPDLOG_INLINE void logger::dump_backtrace() -{ - dump_backtrace_(); -} +SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); } // flush functions -SPDLOG_INLINE void logger::flush() -{ - flush_(); -} +SPDLOG_INLINE void logger::flush() { flush_(); } -SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) -{ - flush_level_.store(log_level); -} +SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } -SPDLOG_INLINE level::level_enum logger::flush_level() const -{ +SPDLOG_INLINE level::level_enum logger::flush_level() const { return static_cast(flush_level_.load(std::memory_order_relaxed)); } // sinks -SPDLOG_INLINE const std::vector &logger::sinks() const -{ - return sinks_; -} +SPDLOG_INLINE const std::vector &logger::sinks() const { return sinks_; } -SPDLOG_INLINE std::vector &logger::sinks() -{ - return sinks_; -} +SPDLOG_INLINE std::vector &logger::sinks() { return sinks_; } // error handler -SPDLOG_INLINE void logger::set_error_handler(err_handler handler) -{ - custom_err_handler_ = std::move(handler); -} +SPDLOG_INLINE void logger::set_error_handler(err_handler handler) { custom_err_handler_ = std::move(handler); } // create new logger with same sinks and configuration. -SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) -{ +SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(logger_name); return cloned; } // protected methods -SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) -{ - if (log_enabled) - { +SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) { + if (log_enabled) { sink_it_(log_msg); } - if (traceback_enabled) - { + if (traceback_enabled) { tracer_.push_back(log_msg); } } -SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) -{ - for (auto &sink : sinks_) - { - if (sink->should_log(msg.level)) - { - SPDLOG_TRY - { - sink->log(msg); - } +SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) { + for (auto &sink : sinks_) { + if (sink->should_log(msg.level)) { + SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } - if (should_flush_(msg)) - { + if (should_flush_(msg)) { flush_(); } } -SPDLOG_INLINE void logger::flush_() -{ - for (auto &sink : sinks_) - { - SPDLOG_TRY - { - sink->flush(); - } +SPDLOG_INLINE void logger::flush_() { + for (auto &sink : sinks_) { + SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } -SPDLOG_INLINE void logger::dump_backtrace_() -{ +SPDLOG_INLINE void logger::dump_backtrace_() { using details::log_msg; - if (tracer_.enabled() && !tracer_.empty()) - { + if (tracer_.enabled() && !tracer_.empty()) { sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"}); tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"}); } } -SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) -{ +SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) { auto flush_level = flush_level_.load(std::memory_order_relaxed); return (msg.level >= flush_level) && (msg.level != level::off); } -SPDLOG_INLINE void logger::err_handler_(const std::string &msg) -{ - if (custom_err_handler_) - { +SPDLOG_INLINE void logger::err_handler_(const std::string &msg) { + if (custom_err_handler_) { custom_err_handler_(msg); - } - else - { + } else { using std::chrono::system_clock; static std::mutex mutex; static std::chrono::system_clock::time_point last_report_time; @@ -239,8 +173,7 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) std::lock_guard lk{mutex}; auto now = system_clock::now(); err_counter++; - if (now - last_report_time < std::chrono::seconds(1)) - { + if (now - last_report_time < std::chrono::seconds(1)) { return; } last_report_time = now; @@ -250,7 +183,8 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) #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 - std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), msg.c_str()); + std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), + msg.c_str()); #endif } } diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 0802a5d9..ab6443b4 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -15,67 +15,58 @@ // formatted data, and support for different format per sink. #include -#include #include +#include #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -# ifndef _WIN32 -# error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows -# endif -# include + #ifndef _WIN32 + #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows + #endif + #include #endif #include #ifndef SPDLOG_NO_EXCEPTIONS -# define SPDLOG_LOGGER_CATCH(location) \ - catch (const std::exception &ex) \ - { \ - if (location.filename) \ - { \ - err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \ - } \ - else \ - { \ - err_handler_(ex.what()); \ - } \ - } \ - catch (...) \ - { \ - err_handler_("Rethrowing unknown exception in logger"); \ - throw; \ + #define SPDLOG_LOGGER_CATCH(location) \ + catch (const std::exception &ex) { \ + if (location.filename) { \ + err_handler_( \ + fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \ + } else { \ + err_handler_(ex.what()); \ + } \ + } \ + catch (...) { \ + err_handler_("Rethrowing unknown exception in logger"); \ + throw; \ } #else -# define SPDLOG_LOGGER_CATCH(location) + #define SPDLOG_LOGGER_CATCH(location) #endif namespace spdlog { -class SPDLOG_API logger -{ +class SPDLOG_API logger { public: // Empty logger explicit logger(std::string name) - : name_(std::move(name)) - , sinks_() - {} + : name_(std::move(name)), + sinks_() {} // Logger with range on sinks - template + template logger(std::string name, It begin, It end) - : name_(std::move(name)) - , sinks_(begin, end) - {} + : name_(std::move(name)), + sinks_(begin, end) {} // Logger with single sink logger(std::string name, sink_ptr single_sink) - : logger(std::move(name), {std::move(single_sink)}) - {} + : logger(std::move(name), {std::move(single_sink)}) {} // Logger with sinks init list logger(std::string name, sinks_init_list sinks) - : logger(std::move(name), sinks.begin(), sinks.end()) - {} + : logger(std::move(name), sinks.begin(), sinks.end()) {} virtual ~logger() = default; @@ -84,37 +75,31 @@ public: logger &operator=(logger other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; - template - void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args &&...args) - { + template + void log(source_loc loc, level::level_enum lvl, format_string_t fmt, Args &&...args) { log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); } - template - void log(level::level_enum lvl, format_string_t fmt, Args &&...args) - { + template + void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { log(source_loc{}, lvl, fmt, std::forward(args)...); } - template - void log(level::level_enum lvl, const T &msg) - { + template + void log(level::level_enum lvl, const T &msg) { log(source_loc{}, lvl, msg); } // T cannot be statically converted to format string (including string_view/wstring_view) - template::value, int>::type = 0> - void log(source_loc loc, level::level_enum lvl, const T &msg) - { + template ::value, int>::type = 0> + void log(source_loc loc, level::level_enum lvl, const T &msg) { log(loc, lvl, "{}", msg); } - void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) - { + void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } @@ -122,12 +107,10 @@ public: log_it_(log_msg, log_enabled, traceback_enabled); } - void log(source_loc loc, level::level_enum lvl, string_view_t msg) - { + void log(source_loc loc, level::level_enum lvl, string_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } @@ -135,66 +118,53 @@ public: log_it_(log_msg, log_enabled, traceback_enabled); } - void log(level::level_enum lvl, string_view_t msg) - { - log(source_loc{}, lvl, msg); - } + void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); } - template - void trace(format_string_t fmt, Args &&...args) - { + template + void trace(format_string_t fmt, Args &&...args) { log(level::trace, fmt, std::forward(args)...); } - template - void debug(format_string_t fmt, Args &&...args) - { + template + void debug(format_string_t fmt, Args &&...args) { log(level::debug, fmt, std::forward(args)...); } - template - void info(format_string_t fmt, Args &&...args) - { + template + void info(format_string_t fmt, Args &&...args) { log(level::info, fmt, std::forward(args)...); } - template - void warn(format_string_t fmt, Args &&...args) - { + template + void warn(format_string_t fmt, Args &&...args) { log(level::warn, fmt, std::forward(args)...); } - template - void error(format_string_t fmt, Args &&...args) - { + template + void error(format_string_t fmt, Args &&...args) { log(level::err, fmt, std::forward(args)...); } - template - void critical(format_string_t fmt, Args &&...args) - { + template + void critical(format_string_t fmt, Args &&...args) { log(level::critical, fmt, std::forward(args)...); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args &&...args) - { + template + void log(source_loc loc, level::level_enum lvl, wformat_string_t fmt, Args &&...args) { log_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); } - template - void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) - { + template + void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { log(source_loc{}, lvl, fmt, std::forward(args)...); } - void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) - { + void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } @@ -204,12 +174,10 @@ public: log_it_(log_msg, log_enabled, traceback_enabled); } - void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) - { + void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } @@ -219,95 +187,74 @@ public: log_it_(log_msg, log_enabled, traceback_enabled); } - void log(level::level_enum lvl, wstring_view_t msg) - { - log(source_loc{}, lvl, msg); - } + void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); } - template - void trace(wformat_string_t fmt, Args &&...args) - { + template + void trace(wformat_string_t fmt, Args &&...args) { log(level::trace, fmt, std::forward(args)...); } - template - void debug(wformat_string_t fmt, Args &&...args) - { + template + void debug(wformat_string_t fmt, Args &&...args) { log(level::debug, fmt, std::forward(args)...); } - template - void info(wformat_string_t fmt, Args &&...args) - { + template + void info(wformat_string_t fmt, Args &&...args) { log(level::info, fmt, std::forward(args)...); } - template - void warn(wformat_string_t fmt, Args &&...args) - { + template + void warn(wformat_string_t fmt, Args &&...args) { log(level::warn, fmt, std::forward(args)...); } - template - void error(wformat_string_t fmt, Args &&...args) - { + template + void error(wformat_string_t fmt, Args &&...args) { log(level::err, fmt, std::forward(args)...); } - template - void critical(wformat_string_t fmt, Args &&...args) - { + template + void critical(wformat_string_t fmt, Args &&...args) { log(level::critical, fmt, std::forward(args)...); } #endif - template - void trace(const T &msg) - { + template + void trace(const T &msg) { log(level::trace, msg); } - template - void debug(const T &msg) - { + template + void debug(const T &msg) { log(level::debug, msg); } - template - void info(const T &msg) - { + template + void info(const T &msg) { log(level::info, msg); } - template - void warn(const T &msg) - { + template + void warn(const T &msg) { log(level::warn, msg); } - template - void error(const T &msg) - { + template + void error(const T &msg) { log(level::err, msg); } - template - void critical(const T &msg) - { + template + void critical(const T &msg) { log(level::critical, msg); } // return true logging is enabled for the given level. - bool should_log(level::level_enum msg_level) const - { - return msg_level >= level_.load(std::memory_order_relaxed); - } + bool should_log(level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } // return true if backtrace logging is enabled. - bool should_backtrace() const - { - return tracer_.enabled(); - } + bool should_backtrace() const { return tracer_.enabled(); } void set_level(level::level_enum log_level); @@ -356,17 +303,14 @@ protected: details::backtracer tracer_; // common implementation for after templated public api has been resolved - template - void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) - { + template + void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } - SPDLOG_TRY - { + SPDLOG_TRY { memory_buf_t buf; #ifdef SPDLOG_USE_STD_FORMAT fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); @@ -381,20 +325,18 @@ protected: } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template - void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) - { + template + void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) - { + if (!log_enabled && !traceback_enabled) { return; } - SPDLOG_TRY - { + SPDLOG_TRY { // format to wmemory_buffer and convert to utf8 wmemory_buf_t wbuf; - fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, fmt_lib::make_format_args(args...)); + fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, + fmt_lib::make_format_args(args...)); memory_buf_t buf; details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); @@ -423,5 +365,5 @@ void swap(logger &a, logger &b); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "logger-inl.h" + #include "logger-inl.h" #endif diff --git a/include/spdlog/pattern_formatter-inl.h b/include/spdlog/pattern_formatter-inl.h index 01afbe6f..c71963dd 100644 --- a/include/spdlog/pattern_formatter-inl.h +++ b/include/spdlog/pattern_formatter-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -15,10 +15,10 @@ #include #include -#include -#include #include +#include #include +#include #include #include #include @@ -34,26 +34,20 @@ namespace details { // name & level pattern appender /////////////////////////////////////////////////////////////////////// -class scoped_padder -{ +class scoped_padder { public: scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest) - : padinfo_(padinfo) - , dest_(dest) - { + : padinfo_(padinfo), + dest_(dest) { remaining_pad_ = static_cast(padinfo.width_) - static_cast(wrapped_size); - if (remaining_pad_ <= 0) - { + if (remaining_pad_ <= 0) { return; } - if (padinfo_.side_ == padding_info::pad_side::left) - { + if (padinfo_.side_ == padding_info::pad_side::left) { pad_it(remaining_pad_); remaining_pad_ = 0; - } - else if (padinfo_.side_ == padding_info::pad_side::center) - { + } else if (padinfo_.side_ == padding_info::pad_side::center) { auto half_pad = remaining_pad_ / 2; auto reminder = remaining_pad_ & 1; pad_it(half_pad); @@ -61,28 +55,22 @@ public: } } - template - static unsigned int count_digits(T n) - { + template + static unsigned int count_digits(T n) { return fmt_helper::count_digits(n); } - ~scoped_padder() - { - if (remaining_pad_ >= 0) - { + ~scoped_padder() { + if (remaining_pad_ >= 0) { pad_it(remaining_pad_); - } - else if (padinfo_.truncate_) - { + } else if (padinfo_.truncate_) { long new_size = static_cast(dest_.size()) + remaining_pad_; dest_.resize(static_cast(new_size)); } } private: - void pad_it(long count) - { + void pad_it(long count) { fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast(count)), dest_); } @@ -92,43 +80,35 @@ private: string_view_t spaces_{" ", 64}; }; -struct null_scoped_padder -{ +struct null_scoped_padder { null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {} - template - static unsigned int count_digits(T /* number */) - { + template + static unsigned int count_digits(T /* number */) { return 0; } }; -template -class name_formatter final : public flag_formatter -{ +template +class name_formatter final : public flag_formatter { public: explicit name_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { ScopedPadder p(msg.logger_name.size(), padinfo_, dest); fmt_helper::append_string_view(msg.logger_name, dest); } }; // log level appender -template -class level_formatter final : public flag_formatter -{ +template +class level_formatter final : public flag_formatter { public: explicit level_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const string_view_t &level_name = level::to_string_view(msg.level); ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); @@ -136,16 +116,13 @@ public: }; // short log level appender -template -class short_level_formatter final : public flag_formatter -{ +template +class short_level_formatter final : public flag_formatter { public: explicit short_level_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { string_view_t level_name{level::to_short_c_str(msg.level)}; ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); @@ -156,29 +133,20 @@ public: // Date time pattern appenders /////////////////////////////////////////////////////////////////////// -static const char *ampm(const tm &t) -{ - return t.tm_hour >= 12 ? "PM" : "AM"; -} +static const char *ampm(const tm &t) { return t.tm_hour >= 12 ? "PM" : "AM"; } -static int to12h(const tm &t) -{ - return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; -} +static int to12h(const tm &t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; } // Abbreviated weekday name static std::array days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}}; -template -class a_formatter final : public flag_formatter -{ +template +class a_formatter final : public flag_formatter { public: explicit a_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{days[static_cast(tm_time.tm_wday)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); @@ -186,18 +154,16 @@ public: }; // Full weekday name -static std::array full_days{{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; +static std::array full_days{ + {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; -template -class A_formatter : public flag_formatter -{ +template +class A_formatter : public flag_formatter { public: explicit A_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{full_days[static_cast(tm_time.tm_wday)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); @@ -205,18 +171,16 @@ public: }; // Abbreviated month -static const std::array months{{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}}; +static const std::array months{ + {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}}; -template -class b_formatter final : public flag_formatter -{ +template +class b_formatter final : public flag_formatter { public: explicit b_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{months[static_cast(tm_time.tm_mon)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); @@ -224,19 +188,16 @@ public: }; // Full month name -static const std::array full_months{ - {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}}; +static const std::array full_months{{"January", "February", "March", "April", "May", "June", "July", + "August", "September", "October", "November", "December"}}; -template -class B_formatter final : public flag_formatter -{ +template +class B_formatter final : public flag_formatter { public: explicit B_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { string_view_t field_value{full_months[static_cast(tm_time.tm_mon)]}; ScopedPadder p(field_value.size(), padinfo_, dest); fmt_helper::append_string_view(field_value, dest); @@ -244,16 +205,13 @@ public: }; // Date and time representation (Thu Aug 23 15:35:46 2014) -template -class c_formatter final : public flag_formatter -{ +template +class c_formatter final : public flag_formatter { public: explicit c_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 24; ScopedPadder p(field_size, padinfo_, dest); @@ -276,16 +234,13 @@ public: }; // year - 2 digit -template -class C_formatter final : public flag_formatter -{ +template +class C_formatter final : public flag_formatter { public: explicit C_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_year % 100, dest); @@ -293,16 +248,13 @@ public: }; // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 -template -class D_formatter final : public flag_formatter -{ +template +class D_formatter final : public flag_formatter { public: explicit D_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 10; ScopedPadder p(field_size, padinfo_, dest); @@ -315,16 +267,13 @@ public: }; // year - 4 digit -template -class Y_formatter final : public flag_formatter -{ +template +class Y_formatter final : public flag_formatter { public: explicit Y_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 4; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(tm_time.tm_year + 1900, dest); @@ -332,16 +281,13 @@ public: }; // month 1-12 -template -class m_formatter final : public flag_formatter -{ +template +class m_formatter final : public flag_formatter { public: explicit m_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_mon + 1, dest); @@ -349,16 +295,13 @@ public: }; // day of month 1-31 -template -class d_formatter final : public flag_formatter -{ +template +class d_formatter final : public flag_formatter { public: explicit d_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_mday, dest); @@ -366,16 +309,13 @@ public: }; // hours in 24 format 0-23 -template -class H_formatter final : public flag_formatter -{ +template +class H_formatter final : public flag_formatter { public: explicit H_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_hour, dest); @@ -383,16 +323,13 @@ public: }; // hours in 12 format 1-12 -template -class I_formatter final : public flag_formatter -{ +template +class I_formatter final : public flag_formatter { public: explicit I_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(to12h(tm_time), dest); @@ -400,16 +337,13 @@ public: }; // minutes 0-59 -template -class M_formatter final : public flag_formatter -{ +template +class M_formatter final : public flag_formatter { public: explicit M_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_min, dest); @@ -417,16 +351,13 @@ public: }; // seconds 0-59 -template -class S_formatter final : public flag_formatter -{ +template +class S_formatter final : public flag_formatter { public: explicit S_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::pad2(tm_time.tm_sec, dest); @@ -434,16 +365,13 @@ public: }; // milliseconds -template -class e_formatter final : public flag_formatter -{ +template +class e_formatter final : public flag_formatter { public: explicit e_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto millis = fmt_helper::time_fraction(msg.time); const size_t field_size = 3; ScopedPadder p(field_size, padinfo_, dest); @@ -452,16 +380,13 @@ public: }; // microseconds -template -class f_formatter final : public flag_formatter -{ +template +class f_formatter final : public flag_formatter { public: explicit f_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto micros = fmt_helper::time_fraction(msg.time); const size_t field_size = 6; @@ -471,16 +396,13 @@ public: }; // nanoseconds -template -class F_formatter final : public flag_formatter -{ +template +class F_formatter final : public flag_formatter { public: explicit F_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto ns = fmt_helper::time_fraction(msg.time); const size_t field_size = 9; ScopedPadder p(field_size, padinfo_, dest); @@ -489,16 +411,13 @@ public: }; // seconds since epoch -template -class E_formatter final : public flag_formatter -{ +template +class E_formatter final : public flag_formatter { public: explicit E_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const size_t field_size = 10; ScopedPadder p(field_size, padinfo_, dest); auto duration = msg.time.time_since_epoch(); @@ -508,16 +427,13 @@ public: }; // AM/PM -template -class p_formatter final : public flag_formatter -{ +template +class p_formatter final : public flag_formatter { public: explicit p_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 2; ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_string_view(ampm(tm_time), dest); @@ -525,16 +441,13 @@ public: }; // 12 hour clock 02:55:02 pm -template -class r_formatter final : public flag_formatter -{ +template +class r_formatter final : public flag_formatter { public: explicit r_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 11; ScopedPadder p(field_size, padinfo_, dest); @@ -549,16 +462,13 @@ public: }; // 24-hour HH:MM time, equivalent to %H:%M -template -class R_formatter final : public flag_formatter -{ +template +class R_formatter final : public flag_formatter { public: explicit R_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 5; ScopedPadder p(field_size, padinfo_, dest); @@ -569,16 +479,13 @@ public: }; // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S -template -class T_formatter final : public flag_formatter -{ +template +class T_formatter final : public flag_formatter { public: explicit T_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 8; ScopedPadder p(field_size, padinfo_, dest); @@ -591,32 +498,26 @@ public: }; // ISO 8601 offset from UTC in timezone (+-HH:MM) -template -class z_formatter final : public flag_formatter -{ +template +class z_formatter final : public flag_formatter { public: explicit z_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} z_formatter() = default; z_formatter(const z_formatter &) = delete; z_formatter &operator=(const z_formatter &) = delete; - void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { const size_t field_size = 6; ScopedPadder p(field_size, padinfo_, dest); auto total_minutes = get_cached_offset(msg, tm_time); bool is_negative = total_minutes < 0; - if (is_negative) - { + if (is_negative) { total_minutes = -total_minutes; dest.push_back('-'); - } - else - { + } else { dest.push_back('+'); } @@ -629,11 +530,9 @@ private: log_clock::time_point last_update_{std::chrono::seconds(0)}; int offset_minutes_{0}; - int get_cached_offset(const log_msg &msg, const std::tm &tm_time) - { + int get_cached_offset(const log_msg &msg, const std::tm &tm_time) { // refresh every 10 seconds - if (msg.time - last_update_ >= std::chrono::seconds(10)) - { + if (msg.time - last_update_ >= std::chrono::seconds(10)) { offset_minutes_ = os::utc_minutes_offset(tm_time); last_update_ = msg.time; } @@ -642,16 +541,13 @@ private: }; // Thread id -template -class t_formatter final : public flag_formatter -{ +template +class t_formatter final : public flag_formatter { public: explicit t_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { const auto field_size = ScopedPadder::count_digits(msg.thread_id); ScopedPadder p(field_size, padinfo_, dest); fmt_helper::append_int(msg.thread_id, dest); @@ -659,16 +555,13 @@ public: }; // Current pid -template -class pid_formatter final : public flag_formatter -{ +template +class pid_formatter final : public flag_formatter { public: explicit pid_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { const auto pid = static_cast(details::os::pid()); auto field_size = ScopedPadder::count_digits(pid); ScopedPadder p(field_size, padinfo_, dest); @@ -676,49 +569,36 @@ public: } }; -template -class v_formatter final : public flag_formatter -{ +template +class v_formatter final : public flag_formatter { public: explicit v_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { ScopedPadder p(msg.payload.size(), padinfo_, dest); fmt_helper::append_string_view(msg.payload, dest); } }; -class ch_formatter final : public flag_formatter -{ +class ch_formatter final : public flag_formatter { public: explicit ch_formatter(char ch) - : ch_(ch) - {} + : ch_(ch) {} - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override - { - dest.push_back(ch_); - } + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { dest.push_back(ch_); } private: char ch_; }; // aggregate user chars to display as is -class aggregate_formatter final : public flag_formatter -{ +class aggregate_formatter final : public flag_formatter { public: aggregate_formatter() = default; - void add_ch(char ch) - { - str_ += ch; - } - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override - { + void add_ch(char ch) { str_ += ch; } + void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { fmt_helper::append_string_view(str_, dest); } @@ -727,57 +607,45 @@ private: }; // mark the color range. expect it to be in the form of "%^colored text%$" -class color_start_formatter final : public flag_formatter -{ +class color_start_formatter final : public flag_formatter { public: explicit color_start_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { msg.color_range_start = dest.size(); } }; -class color_stop_formatter final : public flag_formatter -{ +class color_stop_formatter final : public flag_formatter { public: explicit color_stop_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { msg.color_range_end = dest.size(); } }; // print source location -template -class source_location_formatter final : public flag_formatter -{ +template +class source_location_formatter final : public flag_formatter { public: explicit source_location_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { - if (msg.source.empty()) - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } size_t text_size; - if (padinfo_.enabled()) - { + if (padinfo_.enabled()) { // calc text size for padding based on "filename:line" - text_size = std::char_traits::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1; - } - else - { + text_size = + std::char_traits::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1; + } else { text_size = 0; } @@ -789,18 +657,14 @@ public: }; // print source filename -template -class source_filename_formatter final : public flag_formatter -{ +template +class source_filename_formatter final : public flag_formatter { public: explicit source_filename_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { - if (msg.source.empty()) - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } @@ -810,29 +674,23 @@ public: } }; -template -class short_filename_formatter final : public flag_formatter -{ +template +class short_filename_formatter final : public flag_formatter { public: explicit short_filename_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} #ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable : 4127) // consider using 'if constexpr' instead + #pragma warning(push) + #pragma warning(disable : 4127) // consider using 'if constexpr' instead #endif // _MSC_VER - static const char *basename(const char *filename) - { + 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 - if (sizeof(os::folder_seps) == 2) - { + if (sizeof(os::folder_seps) == 2) { const char *rv = std::strrchr(filename, os::folder_seps[0]); return rv != nullptr ? rv + 1 : filename; - } - else - { + } else { const std::reverse_iterator begin(filename + std::strlen(filename)); const std::reverse_iterator end(filename); @@ -841,13 +699,11 @@ public: } } #ifdef _MSC_VER -# pragma warning(pop) + #pragma warning(pop) #endif // _MSC_VER - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { - if (msg.source.empty()) - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } @@ -858,18 +714,14 @@ public: } }; -template -class source_linenum_formatter final : public flag_formatter -{ +template +class source_linenum_formatter final : public flag_formatter { public: explicit source_linenum_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { - if (msg.source.empty()) - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } @@ -881,18 +733,14 @@ public: }; // print source funcname -template -class source_funcname_formatter final : public flag_formatter -{ +template +class source_funcname_formatter final : public flag_formatter { public: explicit source_funcname_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { - if (msg.source.empty()) - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { + if (msg.source.empty()) { ScopedPadder p(0, padinfo_, dest); return; } @@ -903,19 +751,16 @@ public: }; // print elapsed time since last message -template -class elapsed_formatter final : public flag_formatter -{ +template +class elapsed_formatter final : public flag_formatter { public: using DurationUnits = Units; explicit elapsed_formatter(padding_info padinfo) - : flag_formatter(padinfo) - , last_message_time_(log_clock::now()) - {} + : flag_formatter(padinfo), + last_message_time_(log_clock::now()) {} - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero()); auto delta_units = std::chrono::duration_cast(delta); last_message_time_ = msg.time; @@ -931,15 +776,12 @@ private: // Full info formatter // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v -class full_formatter final : public flag_formatter -{ +class full_formatter final : public flag_formatter { public: explicit full_formatter(padding_info padinfo) - : flag_formatter(padinfo) - {} + : flag_formatter(padinfo) {} - void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override - { + void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { using std::chrono::duration_cast; using std::chrono::milliseconds; using std::chrono::seconds; @@ -948,8 +790,7 @@ public: auto duration = msg.time.time_since_epoch(); auto secs = duration_cast(duration); - if (cache_timestamp_ != secs || cached_datetime_.size() == 0) - { + if (cache_timestamp_ != secs || cached_datetime_.size() == 0) { cached_datetime_.clear(); cached_datetime_.push_back('['); fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); @@ -980,8 +821,7 @@ public: dest.push_back(' '); // append logger name if exists - if (msg.logger_name.size() > 0) - { + if (msg.logger_name.size() > 0) { dest.push_back('['); fmt_helper::append_string_view(msg.logger_name, dest); dest.push_back(']'); @@ -998,10 +838,10 @@ public: dest.push_back(' '); // add source location if present - if (!msg.source.empty()) - { + if (!msg.source.empty()) { dest.push_back('['); - const char *filename = details::short_filename_formatter::basename(msg.source.filename); + const char *filename = + details::short_filename_formatter::basename(msg.source.filename); fmt_helper::append_string_view(filename, dest); dest.push_back(':'); fmt_helper::append_int(msg.source.line, dest); @@ -1019,39 +859,38 @@ private: } // namespace details -SPDLOG_INLINE pattern_formatter::pattern_formatter( - std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags) - : pattern_(std::move(pattern)) - , eol_(std::move(eol)) - , pattern_time_type_(time_type) - , need_localtime_(false) - , last_log_secs_(0) - , custom_handlers_(std::move(custom_user_flags)) -{ +SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, + pattern_time_type time_type, + std::string eol, + custom_flags custom_user_flags) + : pattern_(std::move(pattern)), + eol_(std::move(eol)), + pattern_time_type_(time_type), + need_localtime_(false), + last_log_secs_(0), + custom_handlers_(std::move(custom_user_flags)) { std::memset(&cached_tm_, 0, sizeof(cached_tm_)); compile_pattern_(pattern_); } // use by default full formatter for if pattern is not given SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) - : pattern_("%+") - , eol_(std::move(eol)) - , pattern_time_type_(time_type) - , need_localtime_(true) - , last_log_secs_(0) -{ + : pattern_("%+"), + eol_(std::move(eol)), + pattern_time_type_(time_type), + need_localtime_(true), + last_log_secs_(0) { std::memset(&cached_tm_, 0, sizeof(cached_tm_)); formatters_.push_back(details::make_unique(details::padding_info{})); } -SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const -{ +SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const { custom_flags cloned_custom_formatters; - for (auto &it : custom_handlers_) - { + for (auto &it : custom_handlers_) { cloned_custom_formatters[it.first] = it.second->clone(); } - auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters)); + auto cloned = details::make_unique(pattern_, pattern_time_type_, eol_, + std::move(cloned_custom_formatters)); cloned->need_localtime(need_localtime_); #if defined(__GNUC__) && __GNUC__ < 5 return std::move(cloned); @@ -1060,54 +899,42 @@ SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const #endif } -SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) -{ - if (need_localtime_) - { +SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) { + if (need_localtime_) { const auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); - if (secs != last_log_secs_) - { + if (secs != last_log_secs_) { cached_tm_ = get_time_(msg); last_log_secs_ = secs; } } - for (auto &f : formatters_) - { + for (auto &f : formatters_) { f->format(msg, cached_tm_, dest); } // write eol details::fmt_helper::append_string_view(eol_, dest); } -SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) -{ +SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) { pattern_ = std::move(pattern); need_localtime_ = false; compile_pattern_(pattern_); } -SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) -{ - need_localtime_ = need; -} +SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } -SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) -{ - if (pattern_time_type_ == pattern_time_type::local) - { +SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) { + if (pattern_time_type_ == pattern_time_type::local) { return details::os::localtime(log_clock::to_time_t(msg.time)); } return details::os::gmtime(log_clock::to_time_t(msg.time)); } -template -SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) -{ +template +SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { // process custom flags auto it = custom_handlers_.find(flag); - if (it != custom_handlers_.end()) - { + if (it != custom_handlers_.end()) { auto custom_handler = it->second->clone(); custom_handler->set_padding_info(padding); formatters_.push_back(std::move(custom_handler)); @@ -1115,8 +942,7 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i } // process built-in flags - switch (flag) - { + switch (flag) { case ('+'): // default formatter formatters_.push_back(details::make_unique(padding)); need_localtime_ = true; @@ -1293,15 +1119,18 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i break; case ('u'): // elapsed time since last log message in nanos - formatters_.push_back(details::make_unique>(padding)); + formatters_.push_back( + details::make_unique>(padding)); break; case ('i'): // elapsed time since last log message in micros - formatters_.push_back(details::make_unique>(padding)); + formatters_.push_back( + details::make_unique>(padding)); break; case ('o'): // elapsed time since last log message in millis - formatters_.push_back(details::make_unique>(padding)); + formatters_.push_back( + details::make_unique>(padding)); break; case ('O'): // elapsed time since last log message in seconds @@ -1311,8 +1140,7 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i default: // Unknown flag appears as is auto unknown_flag = details::make_unique(); - if (!padding.truncate_) - { + if (!padding.truncate_) { unknown_flag->add_ch('%'); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); @@ -1320,8 +1148,7 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i // 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 - { + else { padding.truncate_ = false; formatters_.push_back(details::make_unique>(padding)); unknown_flag->add_ch(flag); @@ -1335,19 +1162,17 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) // Advance the given it pass the end of the padding spec found (if any) // Return padding. -SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end) -{ +SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, + std::string::const_iterator end) { using details::padding_info; using details::scoped_padder; const size_t max_width = 64; - if (it == end) - { + if (it == end) { return padding_info{}; } padding_info::pad_side side; - switch (*it) - { + switch (*it) { case '-': side = padding_info::pad_side::right; ++it; @@ -1361,41 +1186,33 @@ SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::stri break; } - if (it == end || !std::isdigit(static_cast(*it))) - { + if (it == end || !std::isdigit(static_cast(*it))) { return padding_info{}; // no padding if no digit found here } auto width = static_cast(*it) - '0'; - for (++it; it != end && std::isdigit(static_cast(*it)); ++it) - { + for (++it; it != end && std::isdigit(static_cast(*it)); ++it) { auto digit = static_cast(*it) - '0'; width = width * 10 + digit; } // search for the optional truncate marker '!' bool truncate; - if (it != end && *it == '!') - { + if (it != end && *it == '!') { truncate = true; ++it; - } - else - { + } else { truncate = false; } return details::padding_info{std::min(width, max_width), side, truncate}; } -SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) -{ +SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) { auto end = pattern.end(); std::unique_ptr user_chars; formatters_.clear(); - for (auto it = pattern.begin(); it != end; ++it) - { - if (*it == '%') - { + for (auto it = pattern.begin(); it != end; ++it) { + if (*it == '%') { if (user_chars) // append user chars found so far { formatters_.push_back(std::move(user_chars)); @@ -1403,26 +1220,18 @@ SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &patter auto padding = handle_padspec_(++it, end); - if (it != end) - { - if (padding.enabled()) - { + if (it != end) { + if (padding.enabled()) { handle_flag_(*it, padding); - } - else - { + } else { handle_flag_(*it, padding); } - } - else - { + } 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) - { + if (!user_chars) { user_chars = details::make_unique(); } user_chars->add_ch(*it); diff --git a/include/spdlog/pattern_formatter.h b/include/spdlog/pattern_formatter.h index 4c87b21e..fec78b1f 100644 --- a/include/spdlog/pattern_formatter.h +++ b/include/spdlog/pattern_formatter.h @@ -13,46 +13,34 @@ #include #include -#include #include +#include namespace spdlog { namespace details { // padding information. -struct padding_info -{ - enum class pad_side - { - left, - right, - center - }; +struct padding_info { + enum class pad_side { left, right, center }; padding_info() = default; padding_info(size_t width, padding_info::pad_side side, bool truncate) - : width_(width) - , side_(side) - , truncate_(truncate) - , enabled_(true) - {} + : width_(width), + side_(side), + truncate_(truncate), + enabled_(true) {} - bool enabled() const - { - return enabled_; - } + bool enabled() const { return enabled_; } size_t width_ = 0; pad_side side_ = pad_side::left; bool truncate_ = false; bool enabled_ = false; }; -class SPDLOG_API flag_formatter -{ +class SPDLOG_API flag_formatter { public: explicit flag_formatter(padding_info padinfo) - : padinfo_(padinfo) - {} + : 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; @@ -63,27 +51,25 @@ protected: } // namespace details -class SPDLOG_API custom_flag_formatter : public details::flag_formatter -{ +class SPDLOG_API custom_flag_formatter : public details::flag_formatter { public: virtual std::unique_ptr clone() const = 0; - void set_padding_info(const details::padding_info &padding) - { - flag_formatter::padinfo_ = padding; - } + void set_padding_info(const details::padding_info &padding) { flag_formatter::padinfo_ = padding; } }; -class SPDLOG_API pattern_formatter final : public formatter -{ +class SPDLOG_API pattern_formatter final : public formatter { public: using custom_flags = std::unordered_map>; - explicit pattern_formatter(std::string pattern, pattern_time_type time_type = pattern_time_type::local, - std::string eol = spdlog::details::os::default_eol, custom_flags custom_user_flags = custom_flags()); + explicit pattern_formatter(std::string pattern, + pattern_time_type time_type = pattern_time_type::local, + std::string eol = spdlog::details::os::default_eol, + custom_flags custom_user_flags = custom_flags()); // use default pattern is not given - explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol); + explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, + std::string eol = spdlog::details::os::default_eol); pattern_formatter(const pattern_formatter &other) = delete; pattern_formatter &operator=(const pattern_formatter &other) = delete; @@ -91,9 +77,8 @@ public: std::unique_ptr clone() const override; void format(const details::log_msg &msg, memory_buf_t &dest) override; - template - pattern_formatter &add_flag(char flag, Args &&...args) - { + template + pattern_formatter &add_flag(char flag, Args &&...args) { custom_handlers_[flag] = details::make_unique(std::forward(args)...); return *this; } @@ -111,7 +96,7 @@ private: custom_flags custom_handlers_; std::tm get_time_(const details::log_msg &msg); - template + template void handle_flag_(char flag, details::padding_info padding); // Extract given pad spec (e.g. %8X) @@ -124,5 +109,5 @@ private: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "pattern_formatter-inl.h" + #include "pattern_formatter-inl.h" #endif diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h index 0087e953..4e1c4c45 100644 --- a/include/spdlog/sinks/android_sink.h +++ b/include/spdlog/sinks/android_sink.h @@ -5,22 +5,22 @@ #ifdef __ANDROID__ -# include -# include -# include -# include -# include + #include + #include + #include + #include + #include -# include -# include -# include -# include -# include -# include + #include + #include + #include + #include + #include + #include -# if !defined(SPDLOG_ANDROID_RETRIES) -# define SPDLOG_ANDROID_RETRIES 2 -# endif + #if !defined(SPDLOG_ANDROID_RETRIES) + #define SPDLOG_ANDROID_RETRIES 2 + #endif namespace spdlog { namespace sinks { @@ -29,26 +29,20 @@ namespace sinks { * Android sink * (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID) */ -template -class android_sink final : public base_sink -{ +template +class android_sink final : public base_sink { public: explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) - : tag_(std::move(tag)) - , use_raw_msg_(use_raw_msg) - {} + : tag_(std::move(tag)), + use_raw_msg_(use_raw_msg) {} protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { const android_LogPriority priority = convert_to_android_(msg.level); memory_buf_t formatted; - if (use_raw_msg_) - { + if (use_raw_msg_) { details::fmt_helper::append_string_view(msg.payload, formatted); - } - else - { + } else { base_sink::formatter_->format(msg, formatted); } formatted.push_back('\0'); @@ -56,20 +50,17 @@ 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) - { + if (ret == -EPERM) { return; // !__android_log_is_loggable } int retry_count = 0; - while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) - { + while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) { details::os::sleep_for_millis(5); ret = android_log(priority, tag_.c_str(), msg_output); retry_count++; } - if (ret < 0) - { + if (ret < 0) { throw_spdlog_ex("logging to Android failed", ret); } } @@ -77,25 +68,24 @@ protected: void flush_() override {} private: - // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against - // __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) - { + // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link + // against + // __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) { 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) - { + template + 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_enum level) - { - switch (level) - { + static android_LogPriority convert_to_android_(spdlog::level::level_enum level) { + switch (level) { case spdlog::level::trace: return ANDROID_LOG_VERBOSE; case spdlog::level::debug: @@ -120,24 +110,22 @@ private: using android_sink_mt = android_sink; using android_sink_st = android_sink; -template +template using android_sink_buf_mt = android_sink; -template +template using android_sink_buf_st = android_sink; } // namespace sinks // Create and register android syslog logger -template -inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") -{ +template +inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") { return Factory::template create(logger_name, tag); } -template -inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") -{ +template +inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") { return Factory::template create(logger_name, tag); } diff --git a/include/spdlog/sinks/ansicolor_sink-inl.h b/include/spdlog/sinks/ansicolor_sink-inl.h index c924fc5b..6575fecc 100644 --- a/include/spdlog/sinks/ansicolor_sink-inl.h +++ b/include/spdlog/sinks/ansicolor_sink-inl.h @@ -4,20 +4,20 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include +#include namespace spdlog { namespace sinks { -template +template SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) - : target_file_(target_file) - , mutex_(ConsoleMutex::mutex()) - , formatter_(details::make_unique()) + : target_file_(target_file), + mutex_(ConsoleMutex::mutex()), + formatter_(details::make_unique()) { set_color_mode(mode); @@ -30,16 +30,14 @@ SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, co colors_.at(level::off) = to_string_(reset); } -template -SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) -{ +template +SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) { std::lock_guard lock(mutex_); colors_.at(static_cast(color_level)) = to_string_(color); } -template -SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) -{ +template +SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) { // Wrap the originally formatted message in color codes. // If color is not supported in the terminal, log as is instead. std::lock_guard lock(mutex_); @@ -47,8 +45,7 @@ SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg msg.color_range_end = 0; memory_buf_t formatted; formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) - { + if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { // before color range print_range_(formatted, 0, msg.color_range_start); // in color range @@ -57,46 +54,39 @@ SPDLOG_INLINE 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()); } fflush(target_file_); } -template -SPDLOG_INLINE void ansicolor_sink::flush() -{ +template +SPDLOG_INLINE void ansicolor_sink::flush() { std::lock_guard lock(mutex_); fflush(target_file_); } -template -SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) -{ +template +SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -SPDLOG_INLINE void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) -{ +template +SPDLOG_INLINE void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } -template -SPDLOG_INLINE bool ansicolor_sink::should_color() -{ +template +SPDLOG_INLINE bool ansicolor_sink::should_color() { return should_do_colors_; } -template -SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) -{ - switch (mode) - { +template +SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) { + switch (mode) { case color_mode::always: should_do_colors_ = true; return; @@ -111,35 +101,30 @@ SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) } } -template -SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t &color_code) -{ +template +SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t &color_code) { fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); } -template -SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) -{ +template +SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); } -template -SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) -{ +template +SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) { return std::string(sv.data(), sv.size()); } // ansicolor_stdout_sink -template +template SPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) - : ansicolor_sink(stdout, mode) -{} + : ansicolor_sink(stdout, mode) {} // ansicolor_stderr_sink -template +template SPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) - : ansicolor_sink(stderr, mode) -{} + : ansicolor_sink(stderr, mode) {} } // namespace sinks } // namespace spdlog diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index 39d966bc..8ef4c4bf 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -3,13 +3,13 @@ #pragma once +#include +#include +#include #include #include #include -#include -#include #include -#include namespace spdlog { namespace sinks { @@ -21,9 +21,8 @@ namespace sinks { * If no color terminal detected, omit the escape codes. */ -template -class ansicolor_sink : public sink -{ +template +class ansicolor_sink : public sink { public: using mutex_t = typename ConsoleMutex::mutex_t; ansicolor_sink(FILE *target_file, color_mode mode); @@ -90,16 +89,14 @@ private: static std::string to_string_(const string_view_t &sv); }; -template -class ansicolor_stdout_sink : public ansicolor_sink -{ +template +class ansicolor_stdout_sink : public ansicolor_sink { public: explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); }; -template -class ansicolor_stderr_sink : public ansicolor_sink -{ +template +class ansicolor_stderr_sink : public ansicolor_sink { public: explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); }; @@ -114,5 +111,5 @@ using ansicolor_stderr_sink_st = ansicolor_stderr_sink -class SPDLOG_API base_sink : public sink -{ +template +class SPDLOG_API base_sink : public sink { public: base_sink(); explicit base_sink(std::unique_ptr formatter); @@ -48,5 +47,5 @@ protected: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "base_sink-inl.h" + #include "base_sink-inl.h" #endif diff --git a/include/spdlog/sinks/basic_file_sink-inl.h b/include/spdlog/sinks/basic_file_sink-inl.h index 8d23f96d..8c75a1a5 100644 --- a/include/spdlog/sinks/basic_file_sink-inl.h +++ b/include/spdlog/sinks/basic_file_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -13,30 +13,28 @@ namespace spdlog { namespace sinks { -template -SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers) - : file_helper_{event_handlers} -{ +template +SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename, + bool truncate, + const file_event_handlers &event_handlers) + : file_helper_{event_handlers} { file_helper_.open(filename, truncate); } -template -SPDLOG_INLINE const filename_t &basic_file_sink::filename() const -{ +template +SPDLOG_INLINE const filename_t &basic_file_sink::filename() const { return file_helper_.filename(); } -template -SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) -{ +template +SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); file_helper_.write(formatted); } -template -SPDLOG_INLINE void basic_file_sink::flush_() -{ +template +SPDLOG_INLINE void basic_file_sink::flush_() { file_helper_.flush(); } diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h index aacc993b..b9132db8 100644 --- a/include/spdlog/sinks/basic_file_sink.h +++ b/include/spdlog/sinks/basic_file_sink.h @@ -5,8 +5,8 @@ #include #include -#include #include +#include #include #include @@ -16,11 +16,12 @@ namespace sinks { /* * Trivial file sink with single file as target */ -template -class basic_file_sink final : public base_sink -{ +template +class basic_file_sink final : public base_sink { public: - explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}); + explicit basic_file_sink(const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}); const filename_t &filename() const; protected: @@ -39,22 +40,24 @@ using basic_file_sink_st = basic_file_sink; // // factory functions // -template -inline std::shared_ptr basic_logger_mt( - const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) -{ +template +inline std::shared_ptr basic_logger_mt(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, event_handlers); } -template -inline std::shared_ptr basic_logger_st( - const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {}) -{ +template +inline std::shared_ptr basic_logger_st(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + const file_event_handlers &event_handlers = {}) { return Factory::template create(logger_name, filename, truncate, event_handlers); } } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "basic_file_sink-inl.h" + #include "basic_file_sink-inl.h" #endif diff --git a/include/spdlog/sinks/callback_sink.h b/include/spdlog/sinks/callback_sink.h index bcd31383..a0b7a151 100644 --- a/include/spdlog/sinks/callback_sink.h +++ b/include/spdlog/sinks/callback_sink.h @@ -4,8 +4,8 @@ #pragma once #include -#include #include +#include #include #include @@ -19,19 +19,14 @@ namespace sinks { /* * Trivial callback sink, gets a callback function and calls it on each log */ -template -class callback_sink final : public base_sink -{ +template +class callback_sink final : public base_sink { public: explicit callback_sink(const custom_log_callback &callback) - : callback_{callback} - {} + : callback_{callback} {} protected: - void sink_it_(const details::log_msg &msg) override - { - callback_(msg); - } + void sink_it_(const details::log_msg &msg) override { callback_(msg); } void flush_() override{}; private: @@ -46,15 +41,13 @@ using callback_sink_st = callback_sink; // // factory functions // -template -inline std::shared_ptr callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback) -{ +template +inline std::shared_ptr callback_logger_mt(const std::string &logger_name, const custom_log_callback &callback) { return Factory::template create(logger_name, callback); } -template -inline std::shared_ptr callback_logger_st(const std::string &logger_name, const custom_log_callback &callback) -{ +template +inline std::shared_ptr callback_logger_st(const std::string &logger_name, const custom_log_callback &callback) { return Factory::template create(logger_name, callback); } diff --git a/include/spdlog/sinks/daily_file_sink.h b/include/spdlog/sinks/daily_file_sink.h index 0770380c..e5189146 100644 --- a/include/spdlog/sinks/daily_file_sink.h +++ b/include/spdlog/sinks/daily_file_sink.h @@ -4,20 +4,20 @@ #pragma once #include +#include #include #include -#include -#include -#include #include -#include #include +#include +#include +#include -#include -#include #include #include +#include #include +#include #include namespace spdlog { @@ -26,29 +26,25 @@ namespace sinks { /* * Generator of daily log file names in format basename.YYYY-MM-DD.ext */ -struct daily_filename_calculator -{ +struct daily_filename_calculator { // Create filename for the form basename.YYYY-MM-DD - static filename_t calc_filename(const filename_t &filename, const tm &now_tm) - { + static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, now_tm.tm_year + 1900, - now_tm.tm_mon + 1, now_tm.tm_mday, ext); + return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), basename, + now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext); } }; /* * Generator of daily log file names with strftime format. * Usages: - * auto sink = std::make_shared("myapp-%Y-%m-%d:%H:%M:%S.log", hour, minute);" - * auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour, minute)" + * auto sink = std::make_shared("myapp-%Y-%m-%d:%H:%M:%S.log", hour, + * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", hour, minute)" * */ -struct daily_filename_format_calculator -{ - static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) - { +struct daily_filename_format_calculator { + static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) std::wstringstream stream; #else @@ -64,23 +60,24 @@ struct daily_filename_format_calculator * If truncate != false , the created file will be truncated. * If max_files > 0, retain only the last max_files and delete previous. */ -template -class daily_file_sink final : public base_sink -{ +template +class daily_file_sink final : public base_sink { public: // create daily file sink which rotates on given time - daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) - : base_filename_(std::move(base_filename)) - , rotation_h_(rotation_hour) - , rotation_m_(rotation_minute) - , file_helper_{event_handlers} - , truncate_(truncate) - , max_files_(max_files) - , filenames_q_() - { - if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) - { + daily_file_sink(filename_t base_filename, + int rotation_hour, + int rotation_minute, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) + : base_filename_(std::move(base_filename)), + rotation_h_(rotation_hour), + rotation_m_(rotation_minute), + file_helper_{event_handlers}, + truncate_(truncate), + max_files_(max_files), + filenames_q_() { + if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) { throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); } @@ -89,25 +86,21 @@ public: file_helper_.open(filename, truncate_); rotation_tp_ = next_rotation_tp_(); - if (max_files_ > 0) - { + if (max_files_ > 0) { init_filenames_q_(); } } - filename_t filename() - { + filename_t filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { auto time = msg.time; bool should_rotate = time >= rotation_tp_; - if (should_rotate) - { + if (should_rotate) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); file_helper_.open(filename, truncate_); rotation_tp_ = next_rotation_tp_(); @@ -117,57 +110,46 @@ protected: file_helper_.write(formatted); // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) - { + if (should_rotate && max_files_ > 0) { delete_old_(); } } - void flush_() override - { - file_helper_.flush(); - } + void flush_() override { file_helper_.flush(); } private: - void init_filenames_q_() - { + void init_filenames_q_() { using details::os::path_exists; filenames_q_ = details::circular_q(static_cast(max_files_)); std::vector filenames; auto now = log_clock::now(); - while (filenames.size() < max_files_) - { + while (filenames.size() < max_files_) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) - { + if (!path_exists(filename)) { break; } filenames.emplace_back(filename); now -= std::chrono::hours(24); } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) - { + for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { filenames_q_.push_back(std::move(*iter)); } } - tm now_tm(log_clock::time_point tp) - { + tm now_tm(log_clock::time_point tp) { time_t tnow = log_clock::to_time_t(tp); return spdlog::details::os::localtime(tnow); } - log_clock::time_point next_rotation_tp_() - { + log_clock::time_point next_rotation_tp_() { auto now = log_clock::now(); tm date = now_tm(now); date.tm_hour = rotation_h_; date.tm_min = rotation_m_; date.tm_sec = 0; auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) - { + if (rotation_time > now) { return rotation_time; } return {rotation_time + std::chrono::hours(24)}; @@ -175,19 +157,16 @@ private: // Delete the file N rotations ago. // Throw spdlog_ex on failure to delete the old file. - void delete_old_() - { + void delete_old_() { using details::os::filename_to_str; using details::os::remove_if_exists; filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) - { + if (filenames_q_.full()) { auto old_filename = std::move(filenames_q_.front()); filenames_q_.pop_front(); bool ok = remove_if_exists(old_filename) == 0; - if (!ok) - { + if (!ok) { filenames_q_.push_back(std::move(current_file)); throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), errno); } @@ -215,33 +194,51 @@ using daily_file_format_sink_st = daily_file_sink -inline std::shared_ptr daily_logger_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); +template +inline std::shared_ptr daily_logger_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); } -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 = {}) -{ - return Factory::template create( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); +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 = {}) { + return Factory::template create(logger_name, filename, hour, minute, truncate, + max_files, event_handlers); } -template -inline std::shared_ptr daily_logger_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); +template +inline std::shared_ptr daily_logger_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); } -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 = {}) -{ - return Factory::template create( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); +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 = {}) { + return Factory::template create(logger_name, filename, hour, minute, truncate, + max_files, event_handlers); } } // namespace spdlog diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 7ec3a2ec..1a540463 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/include/spdlog/sinks/dist_sink.h @@ -19,71 +19,55 @@ namespace spdlog { namespace sinks { -template -class dist_sink : public base_sink -{ +template +class dist_sink : public base_sink { public: dist_sink() = default; explicit dist_sink(std::vector> sinks) - : sinks_(sinks) - {} + : sinks_(sinks) {} dist_sink(const dist_sink &) = delete; dist_sink &operator=(const dist_sink &) = delete; - void add_sink(std::shared_ptr sub_sink) - { + void add_sink(std::shared_ptr sub_sink) { std::lock_guard lock(base_sink::mutex_); sinks_.push_back(sub_sink); } - void remove_sink(std::shared_ptr sub_sink) - { + void remove_sink(std::shared_ptr sub_sink) { std::lock_guard lock(base_sink::mutex_); sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); } - void set_sinks(std::vector> sinks) - { + void set_sinks(std::vector> sinks) { std::lock_guard lock(base_sink::mutex_); sinks_ = std::move(sinks); } - std::vector> &sinks() - { - return sinks_; - } + std::vector> &sinks() { return sinks_; } protected: - void sink_it_(const details::log_msg &msg) override - { - for (auto &sub_sink : sinks_) - { - if (sub_sink->should_log(msg.level)) - { + void sink_it_(const details::log_msg &msg) override { + for (auto &sub_sink : sinks_) { + if (sub_sink->should_log(msg.level)) { sub_sink->log(msg); } } } - void flush_() override - { - for (auto &sub_sink : sinks_) - { + void flush_() override { + for (auto &sub_sink : sinks_) { sub_sink->flush(); } } - void set_pattern_(const std::string &pattern) override - { + void set_pattern_(const std::string &pattern) override { set_formatter_(details::make_unique(pattern)); } - void set_formatter_(std::unique_ptr sink_formatter) override - { + void set_formatter_(std::unique_ptr sink_formatter) override { base_sink::formatter_ = std::move(sink_formatter); - for (auto &sub_sink : sinks_) - { + for (auto &sub_sink : sinks_) { sub_sink->set_formatter(base_sink::formatter_->clone()); } } diff --git a/include/spdlog/sinks/dup_filter_sink.h b/include/spdlog/sinks/dup_filter_sink.h index 3c96549c..7a30c462 100644 --- a/include/spdlog/sinks/dup_filter_sink.h +++ b/include/spdlog/sinks/dup_filter_sink.h @@ -4,13 +4,13 @@ #pragma once #include "dist_sink.h" -#include #include +#include +#include #include #include #include -#include // Duplicate message removal sink. // Skip the message if previous one is identical and less than "max_skip_duration" have passed @@ -36,15 +36,14 @@ namespace spdlog { namespace sinks { -template -class dup_filter_sink : public dist_sink -{ +template +class dup_filter_sink : public dist_sink { public: - template - explicit dup_filter_sink(std::chrono::duration max_skip_duration, level::level_enum notification_level = level::info) - : max_skip_duration_{max_skip_duration} - , log_level_{notification_level} - {} + template + explicit dup_filter_sink(std::chrono::duration max_skip_duration, + level::level_enum notification_level = level::info) + : max_skip_duration_{max_skip_duration}, + log_level_{notification_level} {} protected: std::chrono::microseconds max_skip_duration_; @@ -53,23 +52,21 @@ protected: size_t skip_counter_ = 0; level::level_enum log_level_; - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { bool filtered = filter_(msg); - if (!filtered) - { + if (!filtered) { skip_counter_ += 1; return; } // log the "skipped.." message - if (skip_counter_ > 0) - { + if (skip_counter_ > 0) { char buf[64]; - auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast(skip_counter_)); - if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) - { - details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, string_view_t{buf, static_cast(msg_size)}}; + auto msg_size = + ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..", static_cast(skip_counter_)); + if (msg_size > 0 && static_cast(msg_size) < sizeof(buf)) { + details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_, + string_view_t{buf, static_cast(msg_size)}}; dist_sink::sink_it_(skipped_msg); } } @@ -82,8 +79,7 @@ protected: } // return whether the log msg should be displayed (true) or skipped (false) - bool filter_(const details::log_msg &msg) - { + bool filter_(const details::log_msg &msg) { auto filter_duration = msg.time - last_msg_time_; return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_); } diff --git a/include/spdlog/sinks/hourly_file_sink.h b/include/spdlog/sinks/hourly_file_sink.h index 33dd8948..505e6710 100644 --- a/include/spdlog/sinks/hourly_file_sink.h +++ b/include/spdlog/sinks/hourly_file_sink.h @@ -4,13 +4,13 @@ #pragma once #include +#include #include #include +#include +#include #include #include -#include -#include -#include #include #include @@ -24,15 +24,13 @@ namespace sinks { /* * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext */ -struct hourly_filename_calculator -{ +struct hourly_filename_calculator { // Create filename for the form basename.YYYY-MM-DD-H - static filename_t calc_filename(const filename_t &filename, const tm &now_tm) - { + static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { filename_t basename, ext; std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, - now_tm.tm_mday, now_tm.tm_hour, ext); + return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, now_tm.tm_year + 1900, + now_tm.tm_mon + 1, now_tm.tm_mday, now_tm.tm_hour, ext); } }; @@ -41,46 +39,41 @@ struct hourly_filename_calculator * If truncate != false , the created file will be truncated. * If max_files > 0, retain only the last max_files and delete previous. */ -template -class hourly_file_sink final : public base_sink -{ +template +class hourly_file_sink final : public base_sink { public: // create hourly file sink which rotates on given time - hourly_file_sink( - filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) - : base_filename_(std::move(base_filename)) - , file_helper_{event_handlers} - , truncate_(truncate) - , max_files_(max_files) - , filenames_q_() - { + hourly_file_sink(filename_t base_filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) + : base_filename_(std::move(base_filename)), + file_helper_{event_handlers}, + truncate_(truncate), + max_files_(max_files), + filenames_q_() { auto now = log_clock::now(); auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); file_helper_.open(filename, truncate_); remove_init_file_ = file_helper_.size() == 0; rotation_tp_ = next_rotation_tp_(); - if (max_files_ > 0) - { + if (max_files_ > 0) { init_filenames_q_(); } } - filename_t filename() - { + filename_t filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { auto time = msg.time; bool should_rotate = time >= rotation_tp_; - if (should_rotate) - { - if (remove_init_file_) - { + if (should_rotate) { + if (remove_init_file_) { file_helper_.close(); details::os::remove(file_helper_.filename()); } @@ -94,56 +87,45 @@ protected: file_helper_.write(formatted); // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) - { + if (should_rotate && max_files_ > 0) { delete_old_(); } } - void flush_() override - { - file_helper_.flush(); - } + void flush_() override { file_helper_.flush(); } private: - void init_filenames_q_() - { + void init_filenames_q_() { using details::os::path_exists; filenames_q_ = details::circular_q(static_cast(max_files_)); std::vector filenames; auto now = log_clock::now(); - while (filenames.size() < max_files_) - { + while (filenames.size() < max_files_) { auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) - { + if (!path_exists(filename)) { break; } filenames.emplace_back(filename); now -= std::chrono::hours(1); } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) - { + for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { filenames_q_.push_back(std::move(*iter)); } } - tm now_tm(log_clock::time_point tp) - { + tm now_tm(log_clock::time_point tp) { time_t tnow = log_clock::to_time_t(tp); return spdlog::details::os::localtime(tnow); } - log_clock::time_point next_rotation_tp_() - { + log_clock::time_point next_rotation_tp_() { auto now = log_clock::now(); tm date = now_tm(now); date.tm_min = 0; date.tm_sec = 0; auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) - { + if (rotation_time > now) { return rotation_time; } return {rotation_time + std::chrono::hours(1)}; @@ -151,19 +133,16 @@ private: // Delete the file N rotations ago. // Throw spdlog_ex on failure to delete the old file. - void delete_old_() - { + void delete_old_() { using details::os::filename_to_str; using details::os::remove_if_exists; filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) - { + if (filenames_q_.full()) { auto old_filename = std::move(filenames_q_.front()); filenames_q_.pop_front(); bool ok = remove_if_exists(old_filename) == 0; - if (!ok) - { + if (!ok) { filenames_q_.push_back(std::move(current_file)); SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno)); } @@ -188,17 +167,23 @@ using hourly_file_sink_st = hourly_file_sink; // // factory functions // -template -inline std::shared_ptr hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false, - uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) -{ - return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); +template +inline std::shared_ptr hourly_logger_mt(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, max_files, + event_handlers); } -template -inline std::shared_ptr hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false, - uint16_t max_files = 0, const file_event_handlers &event_handlers = {}) -{ - return Factory::template create(logger_name, filename, truncate, max_files, event_handlers); +template +inline std::shared_ptr hourly_logger_st(const std::string &logger_name, + const filename_t &filename, + bool truncate = false, + uint16_t max_files = 0, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, truncate, max_files, + event_handlers); } } // namespace spdlog diff --git a/include/spdlog/sinks/kafka_sink.h b/include/spdlog/sinks/kafka_sink.h index ce740efc..ab21c10d 100644 --- a/include/spdlog/sinks/kafka_sink.h +++ b/include/spdlog/sinks/kafka_sink.h @@ -10,13 +10,13 @@ // https://github.com/confluentinc/librdkafka // -#include -#include "spdlog/details/log_msg.h" -#include "spdlog/sinks/base_sink.h" -#include "spdlog/details/synchronous_factory.h" -#include "spdlog/details/null_mutex.h" #include "spdlog/async.h" +#include "spdlog/details/log_msg.h" +#include "spdlog/details/null_mutex.h" +#include "spdlog/details/synchronous_factory.h" +#include "spdlog/sinks/base_sink.h" #include +#include // kafka header #include @@ -24,74 +24,57 @@ namespace spdlog { namespace sinks { -struct kafka_sink_config -{ +struct kafka_sink_config { std::string server_addr; std::string produce_topic; int32_t flush_timeout_ms = 1000; kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) - : server_addr{std::move(addr)} - , produce_topic{std::move(topic)} - , flush_timeout_ms(flush_timeout_ms) - {} + : server_addr{std::move(addr)}, + produce_topic{std::move(topic)}, + flush_timeout_ms(flush_timeout_ms) {} }; -template -class kafka_sink : public base_sink -{ +template +class kafka_sink : public base_sink { public: kafka_sink(kafka_sink_config config) - : config_{std::move(config)} - { - try - { + : config_{std::move(config)} { + try { std::string errstr; conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL)); RdKafka::Conf::ConfResult confRes = conf_->set("bootstrap.servers", config_.server_addr, errstr); - if (confRes != RdKafka::Conf::CONF_OK) - { + if (confRes != RdKafka::Conf::CONF_OK) { throw_spdlog_ex(fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr)); } tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC)); - if (tconf_ == nullptr) - { + if (tconf_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create topic config failed")); } producer_.reset(RdKafka::Producer::create(conf_.get(), errstr)); - if (producer_ == nullptr) - { + if (producer_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr)); } topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic, tconf_.get(), errstr)); - if (topic_ == nullptr) - { + if (topic_ == nullptr) { throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr)); } - } - catch (const std::exception &e) - { + } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what())); } } - ~kafka_sink() - { - producer_->flush(config_.flush_timeout_ms); - } + ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); } protected: - void sink_it_(const details::log_msg &msg) override - { - producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void *)msg.payload.data(), msg.payload.size(), NULL, NULL); + void sink_it_(const details::log_msg &msg) override { + producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY, (void *)msg.payload.data(), + msg.payload.size(), NULL, NULL); } - void flush_() override - { - producer_->flush(config_.flush_timeout_ms); - } + void flush_() override { producer_->flush(config_.flush_timeout_ms); } private: kafka_sink_config config_; @@ -106,27 +89,27 @@ using kafka_sink_st = kafka_sink; } // namespace sinks -template -inline std::shared_ptr kafka_logger_mt(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) -{ +template +inline std::shared_ptr kafka_logger_mt(const std::string &logger_name, + spdlog::sinks::kafka_sink_config config) { return Factory::template create(logger_name, config); } -template -inline std::shared_ptr kafka_logger_st(const std::string &logger_name, spdlog::sinks::kafka_sink_config config) -{ +template +inline std::shared_ptr kafka_logger_st(const 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_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) -{ +template +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) -{ +template +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); } diff --git a/include/spdlog/sinks/mongo_sink.h b/include/spdlog/sinks/mongo_sink.h index 6a8927f5..3eaf1c86 100644 --- a/include/spdlog/sinks/mongo_sink.h +++ b/include/spdlog/sinks/mongo_sink.h @@ -25,50 +25,43 @@ namespace spdlog { namespace sinks { -template -class mongo_sink : public base_sink -{ +template +class mongo_sink : public base_sink { public: - mongo_sink(const std::string &db_name, const std::string &collection_name, const std::string &uri = "mongodb://localhost:27017") - try : mongo_sink(std::make_shared(), db_name, collection_name, uri) - {} - catch (const std::exception &e) - { + mongo_sink(const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") try + : mongo_sink(std::make_shared(), db_name, collection_name, uri) { + } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); } - mongo_sink(std::shared_ptr instance, const std::string &db_name, const std::string &collection_name, - const std::string &uri = "mongodb://localhost:27017") - : instance_(std::move(instance)) - , db_name_(db_name) - , coll_name_(collection_name) - { - try - { + mongo_sink(std::shared_ptr instance, + const std::string &db_name, + const std::string &collection_name, + const std::string &uri = "mongodb://localhost:27017") + : instance_(std::move(instance)), + db_name_(db_name), + coll_name_(collection_name) { + try { client_ = spdlog::details::make_unique(mongocxx::uri{uri}); - } - catch (const std::exception &e) - { + } catch (const std::exception &e) { throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what())); } } - ~mongo_sink() - { - flush_(); - } + ~mongo_sink() { flush_(); } protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { using bsoncxx::builder::stream::document; using bsoncxx::builder::stream::finalize; - if (client_ != nullptr) - { - auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data() - << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end()) - << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id" + if (client_ != nullptr) { + auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" + << level::to_string_view(msg.level).data() << "level_num" << msg.level << "message" + << std::string(msg.payload.begin(), msg.payload.end()) << "logger_name" + << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id" << static_cast(msg.thread_id) << finalize; client_->database(db_name_).collection(coll_name_).insert_one(doc.view()); } @@ -90,17 +83,19 @@ using mongo_sink_st = mongo_sink; } // 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") -{ +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") { 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") -{ +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") { return Factory::template create(logger_name, db_name, collection_name, uri); } diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h index bf68ae88..035d1e05 100644 --- a/include/spdlog/sinks/msvc_sink.h +++ b/include/spdlog/sinks/msvc_sink.h @@ -5,21 +5,21 @@ #if defined(_WIN32) -# include -# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -# include -# endif -# include + #include + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #include + #endif + #include -# include -# include + #include + #include -// Avoid including windows.h (https://stackoverflow.com/a/30741042) -# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + // Avoid including windows.h (https://stackoverflow.com/a/30741042) + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); -# else + #else extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); -# endif + #endif extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace spdlog { @@ -27,31 +27,28 @@ namespace sinks { /* * MSVC sink (logging using OutputDebugStringA) */ -template -class msvc_sink : public base_sink -{ +template +class msvc_sink : public base_sink { public: msvc_sink() = default; msvc_sink(bool check_debugger_present) : check_debugger_present_{check_debugger_present} {}; protected: - void sink_it_(const details::log_msg &msg) override - { - if (check_debugger_present_ && !IsDebuggerPresent()) - { + void sink_it_(const details::log_msg &msg) override { + if (check_debugger_present_ && !IsDebuggerPresent()) { return; } memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); formatted.push_back('\0'); // add a null terminator for OutputDebugString -# if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) + #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) wmemory_buf_t wformatted; details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); OutputDebugStringW(wformatted.data()); -# else + #else OutputDebugStringA(formatted.data()); -# endif + #endif } void flush_() override {} diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h index eb832801..31d7b452 100644 --- a/include/spdlog/sinks/null_sink.h +++ b/include/spdlog/sinks/null_sink.h @@ -4,17 +4,16 @@ #pragma once #include -#include #include +#include #include namespace spdlog { namespace sinks { -template -class null_sink : public base_sink -{ +template +class null_sink : public base_sink { protected: void sink_it_(const details::log_msg &) override {} void flush_() override {} @@ -25,17 +24,15 @@ using null_sink_st = null_sink; } // namespace sinks -template -inline std::shared_ptr null_logger_mt(const std::string &logger_name) -{ +template +inline std::shared_ptr null_logger_mt(const std::string &logger_name) { auto null_logger = Factory::template create(logger_name); null_logger->set_level(level::off); return null_logger; } -template -inline std::shared_ptr null_logger_st(const std::string &logger_name) -{ +template +inline std::shared_ptr null_logger_st(const std::string &logger_name) { auto null_logger = Factory::template create(logger_name); null_logger->set_level(level::off); return null_logger; diff --git a/include/spdlog/sinks/ostream_sink.h b/include/spdlog/sinks/ostream_sink.h index 95c1e962..46eadb5f 100644 --- a/include/spdlog/sinks/ostream_sink.h +++ b/include/spdlog/sinks/ostream_sink.h @@ -11,33 +11,26 @@ namespace spdlog { namespace sinks { -template -class ostream_sink final : public base_sink -{ +template +class ostream_sink final : public base_sink { public: explicit ostream_sink(std::ostream &os, bool force_flush = false) - : ostream_(os) - , force_flush_(force_flush) - {} + : ostream_(os), + force_flush_(force_flush) {} ostream_sink(const ostream_sink &) = delete; ostream_sink &operator=(const ostream_sink &) = delete; protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); ostream_.write(formatted.data(), static_cast(formatted.size())); - if (force_flush_) - { + if (force_flush_) { ostream_.flush(); } } - void flush_() override - { - ostream_.flush(); - } + void flush_() override { ostream_.flush(); } std::ostream &ostream_; bool force_flush_; diff --git a/include/spdlog/sinks/qt_sinks.h b/include/spdlog/sinks/qt_sinks.h index 92e53af7..4ccde4f3 100644 --- a/include/spdlog/sinks/qt_sinks.h +++ b/include/spdlog/sinks/qt_sinks.h @@ -18,40 +18,34 @@ #include "spdlog/sinks/base_sink.h" #include -#include #include +#include // // qt_sink class // namespace spdlog { namespace sinks { -template -class qt_sink : public base_sink -{ +template +class qt_sink : public base_sink { public: qt_sink(QObject *qt_object, std::string meta_method) - : qt_object_(qt_object) - , meta_method_(std::move(meta_method)) - { - if (!qt_object_) - { + : qt_object_(qt_object), + meta_method_(std::move(meta_method)) { + if (!qt_object_) { throw_spdlog_ex("qt_sink: qt_object is null"); } } - ~qt_sink() - { - flush_(); - } + ~qt_sink() { flush_(); } protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); const string_view_t str = string_view_t(formatted.data(), formatted.size()); - QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection, + QMetaObject::invokeMethod( + qt_object_, meta_method_.c_str(), Qt::AutoConnection, Q_ARG(QString, QString::fromUtf8(str.data(), static_cast(str.size())).trimmed())); } @@ -67,17 +61,14 @@ private: // Colors can be modified if needed using sink->set_color(level, qtTextCharFormat). // max_lines is the maximum number of lines that the sink will hold before removing the oldest lines. // By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8 support is needed. -template -class qt_color_sink : public base_sink -{ +template +class qt_color_sink : public base_sink { public: qt_color_sink(QTextEdit *qt_text_edit, int max_lines, bool dark_colors = false, bool is_utf8 = false) - : qt_text_edit_(qt_text_edit) - , max_lines_(max_lines) - , is_utf8_(is_utf8) - { - if (!qt_text_edit_) - { + : qt_text_edit_(qt_text_edit), + max_lines_(max_lines), + is_utf8_(is_utf8) { + if (!qt_text_edit_) { throw_spdlog_ex("qt_color_text_sink: text_edit is null"); } @@ -105,48 +96,44 @@ public: colors_.at(level::critical) = format; } - ~qt_color_sink() - { - flush_(); - } + ~qt_color_sink() { flush_(); } - void set_default_color(QTextCharFormat format) - { + void set_default_color(QTextCharFormat format) { // std::lock_guard lock(base_sink::mutex_); default_color_ = format; } - void set_level_color(level::level_enum color_level, QTextCharFormat format) - { + void set_level_color(level::level_enum color_level, QTextCharFormat format) { // std::lock_guard lock(base_sink::mutex_); colors_.at(static_cast(color_level)) = format; } - QTextCharFormat &get_level_color(level::level_enum color_level) - { + QTextCharFormat &get_level_color(level::level_enum color_level) { std::lock_guard lock(base_sink::mutex_); return colors_.at(static_cast(color_level)); } - QTextCharFormat &get_default_color() - { + QTextCharFormat &get_default_color() { std::lock_guard lock(base_sink::mutex_); return default_color_; } protected: - struct invoke_params - { - invoke_params(int max_lines, QTextEdit *q_text_edit, QString payload, QTextCharFormat default_color, QTextCharFormat level_color, - int color_range_start, int color_range_end) - : max_lines(max_lines) - , q_text_edit(q_text_edit) - , payload(std::move(payload)) - , default_color(default_color) - , level_color(level_color) - , color_range_start(color_range_start) - , color_range_end(color_range_end) - {} + struct invoke_params { + invoke_params(int max_lines, + QTextEdit *q_text_edit, + QString payload, + QTextCharFormat default_color, + QTextCharFormat level_color, + int color_range_start, + int color_range_end) + : max_lines(max_lines), + q_text_edit(q_text_edit), + payload(std::move(payload)), + default_color(default_color), + level_color(level_color), + color_range_start(color_range_start), + color_range_end(color_range_end) {} int max_lines; QTextEdit *q_text_edit; QString payload; @@ -156,8 +143,7 @@ protected: int color_range_end; }; - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); @@ -166,28 +152,24 @@ protected: QString payload; int color_range_start = static_cast(msg.color_range_start); int color_range_end = static_cast(msg.color_range_end); - if (is_utf8_) - { + if (is_utf8_) { payload = QString::fromUtf8(str.data(), static_cast(str.size())); // convert color ranges from byte index to character index. - if (msg.color_range_start < msg.color_range_end) - { + if (msg.color_range_start < msg.color_range_end) { color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size(); color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size(); } - } - else - { + } else { 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.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.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); @@ -199,14 +181,12 @@ protected: // It is a static method to ensure that it is handled correctly even if the sink is destroyed prematurely // before it is invoked. - static void invoke_method_(invoke_params params) - { + static void invoke_method_(invoke_params params) { auto *document = params.q_text_edit->document(); QTextCursor cursor(document); // remove first blocks if number of blocks exceeds max_lines - while (document->blockCount() > params.max_lines) - { + while (document->blockCount() > params.max_lines) { cursor.select(QTextCursor::BlockUnderCursor); cursor.removeSelectedText(); cursor.deleteChar(); // delete the newline after the block @@ -216,8 +196,7 @@ protected: cursor.setCharFormat(params.default_color); // if color range not specified or not not valid, just append the text with default color - if (params.color_range_end <= params.color_range_start) - { + if (params.color_range_end <= params.color_range_start) { cursor.insertText(params.payload); return; } @@ -227,7 +206,8 @@ protected: // insert the colorized text cursor.setCharFormat(params.level_color); - cursor.insertText(params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start)); + cursor.insertText( + params.payload.mid(params.color_range_start, params.color_range_end - params.color_range_start)); // insert the text after the color range with default format cursor.setCharFormat(params.default_color); @@ -255,57 +235,55 @@ using qt_color_sink_st = qt_color_sink; // // log to QTextEdit -template -inline std::shared_ptr qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") -{ +template +inline std::shared_ptr +qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") { return Factory::template create(logger_name, qt_object, meta_method); } -template -inline std::shared_ptr qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") -{ +template +inline std::shared_ptr +qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append") { return Factory::template create(logger_name, qt_object, meta_method); } // log to QPlainTextEdit -template -inline std::shared_ptr qt_logger_mt( - const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") -{ +template +inline std::shared_ptr qt_logger_mt(const std::string &logger_name, + QPlainTextEdit *qt_object, + const std::string &meta_method = "appendPlainText") { return Factory::template create(logger_name, qt_object, meta_method); } -template -inline std::shared_ptr qt_logger_st( - const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText") -{ +template +inline std::shared_ptr qt_logger_st(const std::string &logger_name, + QPlainTextEdit *qt_object, + const std::string &meta_method = "appendPlainText") { return Factory::template create(logger_name, qt_object, meta_method); } // log to QObject -template -inline std::shared_ptr qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) -{ +template +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) -{ +template +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); } // log to QTextEdit with colorize output -template -inline std::shared_ptr qt_color_logger_mt( - const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) -{ +template +inline std::shared_ptr +qt_color_logger_mt(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) { return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); } -template -inline std::shared_ptr qt_color_logger_st( - const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) -{ +template +inline std::shared_ptr +qt_color_logger_st(const std::string &logger_name, QTextEdit *qt_text_edit, int max_lines, bool is_utf8 = false) { return Factory::template create(logger_name, qt_text_edit, max_lines, false, is_utf8); } diff --git a/include/spdlog/sinks/ringbuffer_sink.h b/include/spdlog/sinks/ringbuffer_sink.h index 3ca47c6f..3bc736ae 100644 --- a/include/spdlog/sinks/ringbuffer_sink.h +++ b/include/spdlog/sinks/ringbuffer_sink.h @@ -3,10 +3,10 @@ #pragma once -#include "spdlog/sinks/base_sink.h" #include "spdlog/details/circular_q.h" #include "spdlog/details/log_msg_buffer.h" #include "spdlog/details/null_mutex.h" +#include "spdlog/sinks/base_sink.h" #include #include @@ -17,37 +17,31 @@ namespace sinks { /* * Ring buffer sink */ -template -class ringbuffer_sink final : public base_sink -{ +template +class ringbuffer_sink final : public base_sink { public: explicit ringbuffer_sink(size_t n_items) - : q_{n_items} - {} + : q_{n_items} {} - std::vector last_raw(size_t lim = 0) - { + std::vector last_raw(size_t lim = 0) { std::lock_guard lock(base_sink::mutex_); auto items_available = q_.size(); auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; std::vector ret; ret.reserve(n_items); - for (size_t i = (items_available - n_items); i < items_available; i++) - { + for (size_t i = (items_available - n_items); i < items_available; i++) { ret.push_back(q_.at(i)); } return ret; } - std::vector last_formatted(size_t lim = 0) - { + std::vector last_formatted(size_t lim = 0) { std::lock_guard lock(base_sink::mutex_); auto items_available = q_.size(); auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available; std::vector ret; ret.reserve(n_items); - for (size_t i = (items_available - n_items); i < items_available; i++) - { + for (size_t i = (items_available - n_items); i < items_available; i++) { memory_buf_t formatted; base_sink::formatter_->format(q_.at(i), formatted); ret.push_back(SPDLOG_BUF_TO_STRING(formatted)); @@ -56,10 +50,7 @@ public: } protected: - void sink_it_(const details::log_msg &msg) override - { - q_.push_back(details::log_msg_buffer{msg}); - } + void sink_it_(const details::log_msg &msg) override { q_.push_back(details::log_msg_buffer{msg}); } void flush_() override {} private: diff --git a/include/spdlog/sinks/rotating_file_sink-inl.h b/include/spdlog/sinks/rotating_file_sink-inl.h index cf8b9d5c..18a779ed 100644 --- a/include/spdlog/sinks/rotating_file_sink-inl.h +++ b/include/spdlog/sinks/rotating_file_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -23,27 +23,26 @@ namespace spdlog { namespace sinks { -template -SPDLOG_INLINE rotating_file_sink::rotating_file_sink( - filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers &event_handlers) - : base_filename_(std::move(base_filename)) - , max_size_(max_size) - , max_files_(max_files) - , file_helper_{event_handlers} -{ - if (max_size == 0) - { +template +SPDLOG_INLINE rotating_file_sink::rotating_file_sink(filename_t base_filename, + std::size_t max_size, + std::size_t max_files, + bool rotate_on_open, + const file_event_handlers &event_handlers) + : base_filename_(std::move(base_filename)), + max_size_(max_size), + max_files_(max_files), + file_helper_{event_handlers} { + if (max_size == 0) { throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero"); } - if (max_files > 200000) - { + if (max_files > 200000) { 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 - if (rotate_on_open && current_size_ > 0) - { + if (rotate_on_open && current_size_ > 0) { rotate_(); current_size_ = 0; } @@ -51,11 +50,9 @@ SPDLOG_INLINE rotating_file_sink::rotating_file_sink( // calc filename according to index and file extension if exists. // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". -template -SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) -{ - if (index == 0u) - { +template +SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) { + if (index == 0u) { return filename; } @@ -64,16 +61,14 @@ SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); } -template -SPDLOG_INLINE filename_t rotating_file_sink::filename() -{ +template +SPDLOG_INLINE filename_t rotating_file_sink::filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } -template -SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) -{ +template +SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); auto new_size = current_size_ + formatted.size(); @@ -81,11 +76,9 @@ SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &m // rotate if the new estimated file size exceeds max size. // rotate only if the real size > 0 to better deal with full disk (see issue #2261). // we only check the real size when new_size > max_size_ because it is relatively expensive. - if (new_size > max_size_) - { + if (new_size > max_size_) { file_helper_.flush(); - if (file_helper_.size() > 0) - { + if (file_helper_.size() > 0) { rotate_(); new_size = formatted.size(); } @@ -94,9 +87,8 @@ SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &m current_size_ = new_size; } -template -SPDLOG_INLINE void rotating_file_sink::flush_() -{ +template +SPDLOG_INLINE void rotating_file_sink::flush_() { file_helper_.flush(); } @@ -105,33 +97,30 @@ SPDLOG_INLINE void rotating_file_sink::flush_() // log.1.txt -> log.2.txt // log.2.txt -> log.3.txt // log.3.txt -> delete -template -SPDLOG_INLINE void rotating_file_sink::rotate_() -{ +template +SPDLOG_INLINE void rotating_file_sink::rotate_() { using details::os::filename_to_str; using details::os::path_exists; file_helper_.close(); - for (auto i = max_files_; i > 0; --i) - { + for (auto i = max_files_; i > 0; --i) { filename_t src = calc_filename(base_filename_, i - 1); - if (!path_exists(src)) - { + if (!path_exists(src)) { continue; } filename_t target = calc_filename(base_filename_, i); - if (!rename_file_(src, target)) - { + if (!rename_file_(src, target)) { // if failed try again after a small delay. // this is a workaround to a windows issue, where very high rotation // rates can cause the rename to fail with permission denied (because of antivirus?). details::os::sleep_for_millis(100); - if (!rename_file_(src, target)) - { + if (!rename_file_(src, target)) { file_helper_.reopen(true); // truncate the log file anyway to prevent 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), errno); + throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + + filename_to_str(target), + errno); } } } @@ -140,9 +129,9 @@ SPDLOG_INLINE void rotating_file_sink::rotate_() // delete the target if exists, and rename the src file to target // return true on success, false otherwise. -template -SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename, const filename_t &target_filename) -{ +template +SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename, + const filename_t &target_filename) { // try to delete the target file in case it already exists. (void)details::os::remove(target_filename); return details::os::rename(src_filename, target_filename) == 0; diff --git a/include/spdlog/sinks/rotating_file_sink.h b/include/spdlog/sinks/rotating_file_sink.h index ce0d7b1e..e1da2a10 100644 --- a/include/spdlog/sinks/rotating_file_sink.h +++ b/include/spdlog/sinks/rotating_file_sink.h @@ -3,10 +3,10 @@ #pragma once -#include #include #include #include +#include #include #include @@ -18,12 +18,14 @@ namespace sinks { // // Rotating file sink based on size // -template -class rotating_file_sink final : public base_sink -{ +template +class rotating_file_sink final : public base_sink { public: - rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false, - const file_event_handlers &event_handlers = {}); + rotating_file_sink(filename_t base_filename, + std::size_t max_size, + std::size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}); static filename_t calc_filename(const filename_t &filename, std::size_t index); filename_t filename(); @@ -59,23 +61,29 @@ using rotating_file_sink_st = rotating_file_sink; // factory functions // -template -inline std::shared_ptr rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size, - size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) -{ - return Factory::template create( - logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); +template +inline std::shared_ptr rotating_logger_mt(const std::string &logger_name, + const filename_t &filename, + size_t max_file_size, + size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, max_file_size, max_files, + rotate_on_open, event_handlers); } -template -inline std::shared_ptr rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size, - size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {}) -{ - return Factory::template create( - logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); +template +inline std::shared_ptr rotating_logger_st(const std::string &logger_name, + const filename_t &filename, + size_t max_file_size, + size_t max_files, + bool rotate_on_open = false, + const file_event_handlers &event_handlers = {}) { + return Factory::template create(logger_name, filename, max_file_size, max_files, + rotate_on_open, event_handlers); } } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "rotating_file_sink-inl.h" + #include "rotating_file_sink-inl.h" #endif diff --git a/include/spdlog/sinks/sink-inl.h b/include/spdlog/sinks/sink-inl.h index df07adda..e4b27140 100644 --- a/include/spdlog/sinks/sink-inl.h +++ b/include/spdlog/sinks/sink-inl.h @@ -4,22 +4,19 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include -SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const -{ +SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } -SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) -{ +SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { level_.store(log_level, std::memory_order_relaxed); } -SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const -{ +SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index 0a28cccc..fe72e6cd 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -9,8 +9,7 @@ namespace spdlog { namespace sinks { -class SPDLOG_API sink -{ +class SPDLOG_API sink { public: virtual ~sink() = default; virtual void log(const details::log_msg &msg) = 0; @@ -31,5 +30,5 @@ protected: } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "sink-inl.h" + #include "sink-inl.h" #endif diff --git a/include/spdlog/sinks/stdout_color_sinks-inl.h b/include/spdlog/sinks/stdout_color_sinks-inl.h index 066df182..4f19ca9b 100644 --- a/include/spdlog/sinks/stdout_color_sinks-inl.h +++ b/include/spdlog/sinks/stdout_color_sinks-inl.h @@ -4,35 +4,31 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif -#include #include +#include namespace spdlog { -template -SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) -{ +template +SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) -{ +template +SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) -{ +template +SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) -{ +template +SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } } // namespace spdlog diff --git a/include/spdlog/sinks/stdout_color_sinks.h b/include/spdlog/sinks/stdout_color_sinks.h index 420b13ab..f46e2f94 100644 --- a/include/spdlog/sinks/stdout_color_sinks.h +++ b/include/spdlog/sinks/stdout_color_sinks.h @@ -4,9 +4,9 @@ #pragma once #ifdef _WIN32 -# include + #include #else -# include + #include #endif #include @@ -26,20 +26,20 @@ using stderr_color_sink_st = ansicolor_stderr_sink_st; #endif } // namespace sinks -template +template std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); -template +template std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); -template +template std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode = color_mode::automatic); -template +template std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "stdout_color_sinks-inl.h" + #include "stdout_color_sinks-inl.h" #endif diff --git a/include/spdlog/sinks/stdout_sinks-inl.h b/include/spdlog/sinks/stdout_sinks-inl.h index c1754370..37e7a51d 100644 --- a/include/spdlog/sinks/stdout_sinks-inl.h +++ b/include/spdlog/sinks/stdout_sinks-inl.h @@ -4,36 +4,35 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif +#include #include #include -#include #ifdef _WIN32 -// under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) -// so instead we use ::FileWrite -# include + // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) + // so instead we use ::FileWrite + #include -# ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp -# include // WriteFile (..) -# endif + #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp + #include // WriteFile (..) + #endif -# include // _get_osfhandle(..) -# include // _fileno(..) + #include // _get_osfhandle(..) + #include // _fileno(..) #endif // WIN32 namespace spdlog { namespace sinks { -template +template SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) - : mutex_(ConsoleMutex::mutex()) - , file_(file) - , formatter_(details::make_unique()) -{ + : mutex_(ConsoleMutex::mutex()), + file_(file), + formatter_(details::make_unique()) { #ifdef _WIN32 // get windows handle from the FILE* object @@ -42,19 +41,16 @@ SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) // don't throw to support cases where no console is attached, // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). // throw only if non stdout/stderr target is requested (probably regular file and not console). - if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) - { + if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); } #endif // WIN32 } -template -SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) -{ +template +SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) { #ifdef _WIN32 - if (handle_ == INVALID_HANDLE_VALUE) - { + if (handle_ == INVALID_HANDLE_VALUE) { return; } std::lock_guard lock(mutex_); @@ -63,8 +59,7 @@ SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &m auto size = static_cast(formatted.size()); DWORD bytes_written = 0; bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; - if (!ok) - { + if (!ok) { throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); } #else @@ -76,63 +71,54 @@ SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &m ::fflush(file_); // flush every line to terminal } -template -SPDLOG_INLINE void stdout_sink_base::flush() -{ +template +SPDLOG_INLINE void stdout_sink_base::flush() { std::lock_guard lock(mutex_); fflush(file_); } -template -SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) -{ +template +SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -SPDLOG_INLINE void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) -{ +template +SPDLOG_INLINE void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } // stdout sink -template +template SPDLOG_INLINE stdout_sink::stdout_sink() - : stdout_sink_base(stdout) -{} + : stdout_sink_base(stdout) {} // stderr sink -template +template SPDLOG_INLINE stderr_sink::stderr_sink() - : stdout_sink_base(stderr) -{} + : stdout_sink_base(stderr) {} } // namespace sinks // factory methods -template -SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) -{ +template +SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } -template -SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) -{ +template +SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } -template -SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) -{ +template +SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } -template -SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) -{ +template +SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } } // namespace spdlog diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index 6fdc0de3..864cac70 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -3,22 +3,21 @@ #pragma once +#include #include #include #include -#include #ifdef _WIN32 -# include + #include #endif namespace spdlog { namespace sinks { -template -class stdout_sink_base : public sink -{ +template +class stdout_sink_base : public sink { public: using mutex_t = typename ConsoleMutex::mutex_t; explicit stdout_sink_base(FILE *file); @@ -45,16 +44,14 @@ protected: #endif // WIN32 }; -template -class stdout_sink : public stdout_sink_base -{ +template +class stdout_sink : public stdout_sink_base { public: stdout_sink(); }; -template -class stderr_sink : public stdout_sink_base -{ +template +class stderr_sink : public stdout_sink_base { public: stderr_sink(); }; @@ -68,20 +65,20 @@ using stderr_sink_st = stderr_sink; } // namespace sinks // factory methods -template +template std::shared_ptr stdout_logger_mt(const std::string &logger_name); -template +template std::shared_ptr stdout_logger_st(const std::string &logger_name); -template +template std::shared_ptr stderr_logger_mt(const std::string &logger_name); -template +template std::shared_ptr stderr_logger_st(const std::string &logger_name); } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "stdout_sinks-inl.h" + #include "stdout_sinks-inl.h" #endif diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index 7c38fcb5..48a87d04 100644 --- a/include/spdlog/sinks/syslog_sink.h +++ b/include/spdlog/sinks/syslog_sink.h @@ -3,9 +3,9 @@ #pragma once -#include #include #include +#include #include #include @@ -16,53 +16,43 @@ namespace sinks { /** * Sink that write to syslog using the `syscall()` library call. */ -template -class syslog_sink : public base_sink -{ +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} - , syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}} - , ident_{std::move(ident)} - { + : enable_formatting_{enable_formatting}, + syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, + /* spdlog::level::debug */ LOG_DEBUG, + /* spdlog::level::info */ LOG_INFO, + /* spdlog::level::warn */ LOG_WARNING, + /* spdlog::level::err */ LOG_ERR, + /* spdlog::level::critical */ LOG_CRIT, + /* spdlog::level::off */ LOG_INFO}}, + ident_{std::move(ident)} { // set ident to be program name if empty ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); } - ~syslog_sink() override - { - ::closelog(); - } + ~syslog_sink() override { ::closelog(); } syslog_sink(const syslog_sink &) = delete; syslog_sink &operator=(const syslog_sink &) = delete; protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { string_view_t payload; memory_buf_t formatted; - if (enable_formatting_) - { + if (enable_formatting_) { base_sink::formatter_->format(msg, formatted); payload = string_view_t(formatted.data(), formatted.size()); - } - else - { + } else { payload = msg.payload; } size_t length = payload.size(); // limit to max int - if (length > static_cast(std::numeric_limits::max())) - { + if (length > static_cast(std::numeric_limits::max())) { length = static_cast(std::numeric_limits::max()); } @@ -82,8 +72,7 @@ private: // // Simply maps spdlog's log level to syslog priority level. // - int syslog_prio_from_level(const details::log_msg &msg) const - { + int syslog_prio_from_level(const details::log_msg &msg) const { return syslog_levels_.at(static_cast(msg.level)); } }; @@ -93,17 +82,23 @@ using syslog_sink_st = syslog_sink; } // namespace sinks // Create and register a syslog logger -template -inline std::shared_ptr syslog_logger_mt(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, - int syslog_facility = LOG_USER, bool enable_formatting = false) -{ - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); +template +inline std::shared_ptr syslog_logger_mt(const std::string &logger_name, + const std::string &syslog_ident = "", + int syslog_option = 0, + int syslog_facility = LOG_USER, + bool enable_formatting = false) { + return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, + enable_formatting); } -template -inline std::shared_ptr syslog_logger_st(const std::string &logger_name, const std::string &syslog_ident = "", int syslog_option = 0, - int syslog_facility = LOG_USER, bool enable_formatting = false) -{ - return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, enable_formatting); +template +inline std::shared_ptr syslog_logger_st(const std::string &logger_name, + const std::string &syslog_ident = "", + int syslog_option = 0, + int syslog_facility = LOG_USER, + bool enable_formatting = false) { + return Factory::template create(logger_name, syslog_ident, syslog_option, syslog_facility, + enable_formatting); } } // namespace spdlog diff --git a/include/spdlog/sinks/systemd_sink.h b/include/spdlog/sinks/systemd_sink.h index b00a95f2..722337bf 100644 --- a/include/spdlog/sinks/systemd_sink.h +++ b/include/spdlog/sinks/systemd_sink.h @@ -3,14 +3,14 @@ #pragma once -#include -#include #include +#include #include +#include #include #ifndef SD_JOURNAL_SUPPRESS_LOCATION -# define SD_JOURNAL_SUPPRESS_LOCATION + #define SD_JOURNAL_SUPPRESS_LOCATION #endif #include @@ -20,21 +20,19 @@ namespace sinks { /** * Sink that write to systemd journal using the `sd_journal_send()` library call. */ -template -class systemd_sink : public base_sink -{ +template +class systemd_sink : public base_sink { public: systemd_sink(std::string ident = "", bool enable_formatting = false) - : ident_{std::move(ident)} - , enable_formatting_{enable_formatting} - , syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}} - {} + : ident_{std::move(ident)}, + enable_formatting_{enable_formatting}, + syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, + /* spdlog::level::debug */ LOG_DEBUG, + /* spdlog::level::info */ LOG_INFO, + /* spdlog::level::warn */ LOG_WARNING, + /* spdlog::level::err */ LOG_ERR, + /* spdlog::level::critical */ LOG_CRIT, + /* spdlog::level::off */ LOG_INFO}} {} ~systemd_sink() override {} @@ -47,60 +45,52 @@ protected: using levels_array = std::array; levels_array syslog_levels_; - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { int err; string_view_t payload; memory_buf_t formatted; - if (enable_formatting_) - { + if (enable_formatting_) { base_sink::formatter_->format(msg, formatted); payload = string_view_t(formatted.data(), formatted.size()); - } - else - { + } else { payload = msg.payload; } size_t length = payload.size(); // limit to max int - if (length > static_cast(std::numeric_limits::max())) - { + if (length > static_cast(std::numeric_limits::max())) { length = static_cast(std::numeric_limits::max()); } const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; // Do not send source location if not available - if (msg.source.empty()) - { + if (msg.source.empty()) { // Note: function call inside '()' to avoid macro expansion - err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), + err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", + syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", details::os::thread_id(), + "TID=%zu", details::os::thread_id(), #endif - "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), nullptr); - } - else - { - err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", syslog_level(msg.level), + "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), + syslog_identifier.data(), nullptr); + } else { + err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", + syslog_level(msg.level), #ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", details::os::thread_id(), + "TID=%zu", details::os::thread_id(), #endif - "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), syslog_identifier.data(), "CODE_FILE=%s", - msg.source.filename, "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr); + "SYSLOG_IDENTIFIER=%.*s", static_cast(syslog_identifier.size()), + syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, "CODE_LINE=%d", + msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr); } - if (err) - { + if (err) { throw_spdlog_ex("Failed writing to systemd", errno); } } - int syslog_level(level::level_enum l) - { - return syslog_levels_.at(static_cast(l)); - } + int syslog_level(level::level_enum l) { return syslog_levels_.at(static_cast(l)); } void flush_() override {} }; @@ -110,17 +100,15 @@ using systemd_sink_st = systemd_sink; } // namespace sinks // Create and register a syslog logger -template -inline std::shared_ptr systemd_logger_mt( - const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) -{ +template +inline std::shared_ptr +systemd_logger_mt(const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) { return Factory::template create(logger_name, ident, enable_formatting); } -template -inline std::shared_ptr systemd_logger_st( - const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) -{ +template +inline std::shared_ptr +systemd_logger_st(const std::string &logger_name, const std::string &ident = "", bool enable_formatting = false) { return Factory::template create(logger_name, ident, enable_formatting); } } // namespace spdlog diff --git a/include/spdlog/sinks/tcp_sink.h b/include/spdlog/sinks/tcp_sink.h index e0efb31d..d783f32b 100644 --- a/include/spdlog/sinks/tcp_sink.h +++ b/include/spdlog/sinks/tcp_sink.h @@ -4,18 +4,18 @@ #pragma once #include -#include #include +#include #ifdef _WIN32 -# include + #include #else -# include + #include #endif -#include -#include #include #include +#include +#include #pragma once @@ -27,30 +27,25 @@ namespace spdlog { namespace sinks { -struct tcp_sink_config -{ +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 tcp_sink_config(std::string host, int port) - : server_host{std::move(host)} - , server_port{port} - {} + : server_host{std::move(host)}, + server_port{port} {} }; -template -class tcp_sink : public spdlog::sinks::base_sink -{ +template +class tcp_sink : public spdlog::sinks::base_sink { public: // connect to tcp host/port or throw if failed // host can be hostname or ip address explicit tcp_sink(tcp_sink_config sink_config) - : config_{std::move(sink_config)} - { - if (!config_.lazy_connect) - { + : config_{std::move(sink_config)} { + if (!config_.lazy_connect) { this->client_.connect(config_.server_host, config_.server_port); } } @@ -58,12 +53,10 @@ public: ~tcp_sink() override = default; protected: - void sink_it_(const spdlog::details::log_msg &msg) override - { + void sink_it_(const spdlog::details::log_msg &msg) override { spdlog::memory_buf_t formatted; spdlog::sinks::base_sink::formatter_->format(msg, formatted); - if (!client_.is_connected()) - { + if (!client_.is_connected()) { client_.connect(config_.server_host, config_.server_port); } client_.send(formatted.data(), formatted.size()); diff --git a/include/spdlog/sinks/udp_sink.h b/include/spdlog/sinks/udp_sink.h index ccbce2be..d38c5590 100644 --- a/include/spdlog/sinks/udp_sink.h +++ b/include/spdlog/sinks/udp_sink.h @@ -4,18 +4,18 @@ #pragma once #include -#include #include +#include #ifdef _WIN32 -# include + #include #else -# include + #include #endif -#include -#include #include #include +#include +#include // Simple udp client sink // Sends formatted log via udp @@ -23,31 +23,26 @@ namespace spdlog { namespace sinks { -struct udp_sink_config -{ +struct udp_sink_config { std::string server_host; uint16_t server_port; udp_sink_config(std::string host, uint16_t port) - : server_host{std::move(host)} - , server_port{port} - {} + : server_host{std::move(host)}, + server_port{port} {} }; -template -class udp_sink : public spdlog::sinks::base_sink -{ +template +class udp_sink : public spdlog::sinks::base_sink { public: // host can be hostname or ip address explicit udp_sink(udp_sink_config sink_config) - : client_{sink_config.server_host, sink_config.server_port} - {} + : client_{sink_config.server_host, sink_config.server_port} {} ~udp_sink() override = default; protected: - void sink_it_(const spdlog::details::log_msg &msg) override - { + void sink_it_(const spdlog::details::log_msg &msg) override { spdlog::memory_buf_t formatted; spdlog::sinks::base_sink::formatter_->format(msg, formatted); client_.send(formatted.data(), formatted.size()); @@ -65,9 +60,8 @@ using udp_sink_st = udp_sink; // // factory functions // -template -inline std::shared_ptr udp_logger_mt(const std::string &logger_name, sinks::udp_sink_config skin_config) -{ +template +inline std::shared_ptr udp_logger_mt(const std::string &logger_name, sinks::udp_sink_config skin_config) { return Factory::template create(logger_name, skin_config); } diff --git a/include/spdlog/sinks/win_eventlog_sink.h b/include/spdlog/sinks/win_eventlog_sink.h index d23d00a8..ca16ad84 100644 --- a/include/spdlog/sinks/win_eventlog_sink.h +++ b/include/spdlog/sinks/win_eventlog_sink.h @@ -47,8 +47,7 @@ namespace win_eventlog { namespace internal { -struct local_alloc_t -{ +struct local_alloc_t { HLOCAL hlocal_; SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} @@ -56,30 +55,25 @@ struct local_alloc_t local_alloc_t(local_alloc_t const &) = delete; local_alloc_t &operator=(local_alloc_t const &) = delete; - ~local_alloc_t() SPDLOG_NOEXCEPT - { - if (hlocal_) - { + ~local_alloc_t() SPDLOG_NOEXCEPT { + if (hlocal_) { LocalFree(hlocal_); } } }; /** Windows error */ -struct win32_error : public spdlog_ex -{ +struct win32_error : public spdlog_ex { /** Formats an error report line: "user-message: error-code (system message)" */ - static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) - { + static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) { std::string system_message; local_alloc_t format_message_result{}; - auto format_message_succeeded = - ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, - error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr); + auto format_message_succeeded = ::FormatMessageA( + FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, + error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result.hlocal_, 0, nullptr); - if (format_message_succeeded && format_message_result.hlocal_) - { + if (format_message_succeeded && format_message_result.hlocal_) { system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); } @@ -87,23 +81,19 @@ struct win32_error : public spdlog_ex } explicit win32_error(std::string const &func_name, DWORD error = GetLastError()) - : spdlog_ex(format(func_name, error)) - {} + : spdlog_ex(format(func_name, error)) {} }; /** Wrapper for security identifiers (SID) on Windows */ -struct sid_t -{ +struct sid_t { std::vector buffer_; public: sid_t() {} /** creates a wrapped SID copy */ - static sid_t duplicate_sid(PSID psid) - { - if (!::IsValidSid(psid)) - { + static sid_t duplicate_sid(PSID psid) { + if (!::IsValidSid(psid)) { throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); } @@ -111,8 +101,7 @@ public: sid_t result; result.buffer_.resize(sid_length); - if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) - { + if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) { SPDLOG_THROW(win32_error("CopySid")); } @@ -120,44 +109,33 @@ public: } /** Retrieves pointer to the internal buffer contents as SID* */ - SID *as_sid() const - { - return buffer_.empty() ? nullptr : (SID *)buffer_.data(); - } + SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); } /** Get SID for the current user */ - static sid_t get_current_user_sid() - { + static sid_t get_current_user_sid() { /* create and init RAII holder for process token */ - struct process_token_t - { + struct process_token_t { HANDLE token_handle_ = INVALID_HANDLE_VALUE; - explicit process_token_t(HANDLE process) - { - if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) - { + explicit process_token_t(HANDLE process) { + if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) { SPDLOG_THROW(win32_error("OpenProcessToken")); } } - ~process_token_t() - { - ::CloseHandle(token_handle_); - } + ~process_token_t() { ::CloseHandle(token_handle_); } } current_process_token(::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 DWORD tusize = 0; - if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) - { + if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) { SPDLOG_THROW(win32_error("GetTokenInformation should fail")); } // get user token std::vector buffer(static_cast(tusize)); - if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, &tusize)) - { + if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, (LPVOID)buffer.data(), tusize, + &tusize)) { SPDLOG_THROW(win32_error("GetTokenInformation")); } @@ -166,12 +144,9 @@ public: } }; -struct eventlog -{ - static WORD get_event_type(details::log_msg const &msg) - { - switch (msg.level) - { +struct eventlog { + static WORD get_event_type(details::log_msg const &msg) { + switch (msg.level) { case level::trace: case level::debug: return EVENTLOG_SUCCESS; @@ -192,10 +167,7 @@ struct eventlog } } - static WORD get_event_category(details::log_msg const &msg) - { - return (WORD)msg.level; - } + static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; } }; } // namespace internal @@ -203,22 +175,18 @@ struct eventlog /* * Windows Event Log sink */ -template -class win_eventlog_sink : public base_sink -{ +template +class win_eventlog_sink : public base_sink { private: HANDLE hEventLog_{NULL}; internal::sid_t current_user_sid_; std::string source_; DWORD event_id_; - HANDLE event_log_handle() - { - if (!hEventLog_) - { + HANDLE event_log_handle() { + if (!hEventLog_) { hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); - if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) - { + if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) { SPDLOG_THROW(internal::win32_error("RegisterEventSource")); } } @@ -227,8 +195,7 @@ private: } protected: - void sink_it_(const details::log_msg &msg) override - { + void sink_it_(const details::log_msg &msg) override { using namespace internal; bool succeeded; @@ -241,16 +208,17 @@ protected: details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); LPCWSTR lp_wstr = buf.data(); - succeeded = static_cast(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), - event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); + succeeded = static_cast(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), + eventlog::get_event_category(msg), event_id_, + current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); #else LPCSTR lp_str = formatted.data(); - succeeded = static_cast(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), - event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); + succeeded = static_cast(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), + eventlog::get_event_category(msg), event_id_, + current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); #endif - if (!succeeded) - { + if (!succeeded) { SPDLOG_THROW(win32_error("ReportEvent")); } } @@ -259,22 +227,17 @@ protected: public: win_eventlog_sink(std::string const &source, DWORD event_id = 1000 /* according to mscoree.dll */) - : source_(source) - , event_id_(event_id) - { - try - { + : source_(source), + event_id_(event_id) { + try { current_user_sid_ = internal::sid_t::get_current_user_sid(); - } - catch (...) - { + } catch (...) { // get_current_user_sid() is unlikely to fail and if it does, we can still proceed without // current_user_sid but in the event log the record will have no user name } } - ~win_eventlog_sink() - { + ~win_eventlog_sink() { if (hEventLog_) DeregisterEventSource(hEventLog_); } diff --git a/include/spdlog/sinks/wincolor_sink-inl.h b/include/spdlog/sinks/wincolor_sink-inl.h index 8311929e..186bf983 100644 --- a/include/spdlog/sinks/wincolor_sink-inl.h +++ b/include/spdlog/sinks/wincolor_sink-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -15,12 +15,11 @@ namespace spdlog { namespace sinks { -template +template SPDLOG_INLINE wincolor_sink::wincolor_sink(void *out_handle, color_mode mode) - : out_handle_(out_handle) - , mutex_(ConsoleMutex::mutex()) - , formatter_(details::make_unique()) -{ + : out_handle_(out_handle), + mutex_(ConsoleMutex::mutex()), + formatter_(details::make_unique()) { set_color_mode_impl(mode); // set level colors @@ -29,30 +28,26 @@ SPDLOG_INLINE wincolor_sink::wincolor_sink(void *out_handle, color colors_[level::info] = FOREGROUND_GREEN; // green colors_[level::warn] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red - colors_[level::critical] = - BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background + colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | + FOREGROUND_INTENSITY; // intense white on red background colors_[level::off] = 0; } -template -SPDLOG_INLINE wincolor_sink::~wincolor_sink() -{ +template +SPDLOG_INLINE wincolor_sink::~wincolor_sink() { this->flush(); } // change the color for the given level -template -void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, std::uint16_t color) -{ +template +void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, std::uint16_t color) { std::lock_guard lock(mutex_); colors_[static_cast(level)] = color; } -template -void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) -{ - if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) - { +template +void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) { + if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) { return; } @@ -61,8 +56,7 @@ void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) msg.color_range_end = 0; memory_buf_t formatted; formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) - { + if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { // before color range print_range_(formatted, 0, msg.color_range_start); // in color range @@ -71,63 +65,52 @@ void SPDLOG_INLINE 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); } } -template -void SPDLOG_INLINE wincolor_sink::flush() -{ +template +void SPDLOG_INLINE wincolor_sink::flush() { // windows console always flushed? } -template -void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) -{ +template +void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -void SPDLOG_INLINE wincolor_sink::set_formatter(std::unique_ptr sink_formatter) -{ +template +void SPDLOG_INLINE wincolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } -template -void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) -{ +template +void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) { std::lock_guard lock(mutex_); set_color_mode_impl(mode); } -template -void SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) -{ - if (mode == color_mode::automatic) - { +template +void SPDLOG_INLINE wincolor_sink::set_color_mode_impl(color_mode mode) { + if (mode == color_mode::automatic) { // should do colors only if out_handle_ points to actual console. DWORD console_mode; bool in_console = ::GetConsoleMode(static_cast(out_handle_), &console_mode) != 0; should_do_colors_ = in_console; - } - else - { + } else { should_do_colors_ = mode == color_mode::always ? true : false; } } // set foreground color and return the orig console attributes (for resetting later) -template -std::uint16_t SPDLOG_INLINE wincolor_sink::set_foreground_color_(std::uint16_t attribs) -{ +template +std::uint16_t SPDLOG_INLINE wincolor_sink::set_foreground_color_(std::uint16_t attribs) { CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; - if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) - { + if (!::GetConsoleScreenBufferInfo(static_cast(out_handle_), &orig_buffer_info)) { // just return white if failed getting console info return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; } @@ -140,20 +123,18 @@ std::uint16_t SPDLOG_INLINE wincolor_sink::set_foreground_color_(s } // print a range of formatted message to console -template -void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) -{ - if (end > start) - { +template +void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { + if (end > start) { auto size = static_cast(end - start); - auto ignored = ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start, size, nullptr, nullptr); + auto ignored = + ::WriteConsoleA(static_cast(out_handle_), formatted.data() + start, size, nullptr, nullptr); (void)(ignored); } } -template -void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) -{ +template +void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) { auto size = static_cast(formatted.size()); DWORD bytes_written = 0; auto ignored = ::WriteFile(static_cast(out_handle_), formatted.data(), size, &bytes_written, nullptr); @@ -161,15 +142,13 @@ void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_ } // wincolor_stdout_sink -template +template SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) - : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) -{} + : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {} // wincolor_stderr_sink -template +template SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) - : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) -{} + : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} } // namespace sinks } // namespace spdlog diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index 9b030fc1..5de60b22 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -8,11 +8,11 @@ #include #include +#include +#include #include #include #include -#include -#include namespace spdlog { namespace sinks { @@ -20,9 +20,8 @@ namespace sinks { * Windows color console sink. Uses WriteConsoleA to write to the console with * colors */ -template -class wincolor_sink : public sink -{ +template +class wincolor_sink : public sink { public: wincolor_sink(void *out_handle, color_mode mode); ~wincolor_sink() override; @@ -58,16 +57,14 @@ protected: void set_color_mode_impl(color_mode mode); }; -template -class wincolor_stdout_sink : public wincolor_sink -{ +template +class wincolor_stdout_sink : public wincolor_sink { public: explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); }; -template -class wincolor_stderr_sink : public wincolor_sink -{ +template +class wincolor_stderr_sink : public wincolor_sink { public: explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); }; @@ -81,5 +78,5 @@ using wincolor_stderr_sink_st = wincolor_stderr_sink } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY -# include "wincolor_sink-inl.h" + #include "wincolor_sink-inl.h" #endif diff --git a/include/spdlog/spdlog-inl.h b/include/spdlog/spdlog-inl.h index 22ea22bb..b888de84 100644 --- a/include/spdlog/spdlog-inl.h +++ b/include/spdlog/spdlog-inl.h @@ -4,7 +4,7 @@ #pragma once #ifndef SPDLOG_HEADER_ONLY -# include + #include #endif #include @@ -12,113 +12,67 @@ namespace spdlog { -SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) -{ +SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } -SPDLOG_INLINE std::shared_ptr get(const std::string &name) -{ - return details::registry::instance().get(name); -} +SPDLOG_INLINE std::shared_ptr get(const std::string &name) { return details::registry::instance().get(name); } -SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) -{ +SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) { details::registry::instance().set_formatter(std::move(formatter)); } -SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) -{ +SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } -SPDLOG_INLINE void enable_backtrace(size_t n_messages) -{ - details::registry::instance().enable_backtrace(n_messages); -} +SPDLOG_INLINE void enable_backtrace(size_t n_messages) { details::registry::instance().enable_backtrace(n_messages); } -SPDLOG_INLINE void disable_backtrace() -{ - details::registry::instance().disable_backtrace(); -} +SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } -SPDLOG_INLINE void dump_backtrace() -{ - default_logger_raw()->dump_backtrace(); -} +SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } -SPDLOG_INLINE level::level_enum get_level() -{ - return default_logger_raw()->level(); -} +SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } -SPDLOG_INLINE bool should_log(level::level_enum log_level) -{ - return default_logger_raw()->should_log(log_level); -} +SPDLOG_INLINE bool should_log(level::level_enum log_level) { return default_logger_raw()->should_log(log_level); } -SPDLOG_INLINE void set_level(level::level_enum log_level) -{ - details::registry::instance().set_level(log_level); -} +SPDLOG_INLINE void set_level(level::level_enum log_level) { details::registry::instance().set_level(log_level); } -SPDLOG_INLINE void flush_on(level::level_enum log_level) -{ - details::registry::instance().flush_on(log_level); -} +SPDLOG_INLINE void flush_on(level::level_enum log_level) { details::registry::instance().flush_on(log_level); } -SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) -{ +SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) { details::registry::instance().set_error_handler(handler); } -SPDLOG_INLINE void register_logger(std::shared_ptr logger) -{ +SPDLOG_INLINE void register_logger(std::shared_ptr logger) { details::registry::instance().register_logger(std::move(logger)); } -SPDLOG_INLINE void apply_all(const std::function)> &fun) -{ +SPDLOG_INLINE void apply_all(const std::function)> &fun) { details::registry::instance().apply_all(fun); } -SPDLOG_INLINE void drop(const std::string &name) -{ - details::registry::instance().drop(name); -} +SPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); } -SPDLOG_INLINE void drop_all() -{ - details::registry::instance().drop_all(); -} +SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } -SPDLOG_INLINE void shutdown() -{ - details::registry::instance().shutdown(); -} +SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } -SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) -{ +SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { details::registry::instance().set_automatic_registration(automatic_registration); } -SPDLOG_INLINE std::shared_ptr default_logger() -{ +SPDLOG_INLINE std::shared_ptr default_logger() { return details::registry::instance().default_logger(); } -SPDLOG_INLINE spdlog::logger *default_logger_raw() -{ - return details::registry::instance().get_default_raw(); -} +SPDLOG_INLINE spdlog::logger *default_logger_raw() { return details::registry::instance().get_default_raw(); } -SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) -{ +SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) { details::registry::instance().set_default_logger(std::move(default_logger)); } -SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) -{ +SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) { details::registry::instance().apply_logger_env_levels(std::move(logger)); } diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index fbfe5fb8..b2a20317 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -11,9 +11,9 @@ #include #include +#include #include #include -#include #include #include @@ -30,9 +30,8 @@ using default_factory = synchronous_factory; // // Example: // spdlog::create("logger_name", "dailylog_filename", 11, 59); -template -inline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) -{ +template +inline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) { return default_factory::create(std::move(logger_name), std::forward(sink_args)...); } @@ -81,9 +80,8 @@ SPDLOG_API void flush_on(level::level_enum log_level); // Start/Restart a periodic flusher thread // Warning: Use only if all your loggers are thread safe! -template -inline void flush_every(std::chrono::duration interval) -{ +template +inline void flush_every(std::chrono::duration interval) { details::registry::instance().flush_every(interval); } @@ -140,149 +138,125 @@ SPDLOG_API void set_default_logger(std::shared_ptr default_logge // spdlog::apply_logger_env_levels(mylogger); SPDLOG_API void apply_logger_env_levels(std::shared_ptr logger); -template -inline void log(source_loc source, level::level_enum lvl, format_string_t fmt, Args &&...args) -{ +template +inline void log(source_loc source, level::level_enum lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); } -template -inline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) -{ +template +inline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); } -template -inline void trace(format_string_t fmt, Args &&...args) -{ +template +inline void trace(format_string_t fmt, Args &&...args) { default_logger_raw()->trace(fmt, std::forward(args)...); } -template -inline void debug(format_string_t fmt, Args &&...args) -{ +template +inline void debug(format_string_t fmt, Args &&...args) { default_logger_raw()->debug(fmt, std::forward(args)...); } -template -inline void info(format_string_t fmt, Args &&...args) -{ +template +inline void info(format_string_t fmt, Args &&...args) { default_logger_raw()->info(fmt, std::forward(args)...); } -template -inline void warn(format_string_t fmt, Args &&...args) -{ +template +inline void warn(format_string_t fmt, Args &&...args) { default_logger_raw()->warn(fmt, std::forward(args)...); } -template -inline void error(format_string_t fmt, Args &&...args) -{ +template +inline void error(format_string_t fmt, Args &&...args) { default_logger_raw()->error(fmt, std::forward(args)...); } -template -inline void critical(format_string_t fmt, Args &&...args) -{ +template +inline void critical(format_string_t fmt, Args &&...args) { default_logger_raw()->critical(fmt, std::forward(args)...); } -template -inline void log(source_loc source, level::level_enum lvl, const T &msg) -{ +template +inline void log(source_loc source, level::level_enum lvl, const T &msg) { default_logger_raw()->log(source, lvl, msg); } -template -inline void log(level::level_enum lvl, const T &msg) -{ +template +inline void log(level::level_enum lvl, const T &msg) { default_logger_raw()->log(lvl, msg); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -template -inline void log(source_loc source, level::level_enum lvl, wformat_string_t fmt, Args &&...args) -{ +template +inline void log(source_loc source, level::level_enum lvl, wformat_string_t fmt, Args &&...args) { default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); } -template -inline void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) -{ +template +inline void log(level::level_enum lvl, wformat_string_t fmt, Args &&...args) { default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); } -template -inline void trace(wformat_string_t fmt, Args &&...args) -{ +template +inline void trace(wformat_string_t fmt, Args &&...args) { default_logger_raw()->trace(fmt, std::forward(args)...); } -template -inline void debug(wformat_string_t fmt, Args &&...args) -{ +template +inline void debug(wformat_string_t fmt, Args &&...args) { default_logger_raw()->debug(fmt, std::forward(args)...); } -template -inline void info(wformat_string_t fmt, Args &&...args) -{ +template +inline void info(wformat_string_t fmt, Args &&...args) { default_logger_raw()->info(fmt, std::forward(args)...); } -template -inline void warn(wformat_string_t fmt, Args &&...args) -{ +template +inline void warn(wformat_string_t fmt, Args &&...args) { default_logger_raw()->warn(fmt, std::forward(args)...); } -template -inline void error(wformat_string_t fmt, Args &&...args) -{ +template +inline void error(wformat_string_t fmt, Args &&...args) { default_logger_raw()->error(fmt, std::forward(args)...); } -template -inline void critical(wformat_string_t fmt, Args &&...args) -{ +template +inline void critical(wformat_string_t fmt, Args &&...args) { default_logger_raw()->critical(fmt, std::forward(args)...); } #endif -template -inline void trace(const T &msg) -{ +template +inline void trace(const T &msg) { default_logger_raw()->trace(msg); } -template -inline void debug(const T &msg) -{ +template +inline void debug(const T &msg) { default_logger_raw()->debug(msg); } -template -inline void info(const T &msg) -{ +template +inline void info(const T &msg) { default_logger_raw()->info(msg); } -template -inline void warn(const T &msg) -{ +template +inline void warn(const T &msg) { default_logger_raw()->warn(msg); } -template -inline void error(const T &msg) -{ +template +inline void error(const T &msg) { default_logger_raw()->error(msg); } -template -inline void critical(const T &msg) -{ +template +inline void critical(const T &msg) { default_logger_raw()->critical(msg); } @@ -302,62 +276,62 @@ inline void critical(const T &msg) // #ifndef SPDLOG_NO_SOURCE_LOC -# define SPDLOG_LOGGER_CALL(logger, level, ...) \ + #define SPDLOG_LOGGER_CALL(logger, level, ...) \ (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) #else -# define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) + #define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE -# define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) -# define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) + #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 -# define SPDLOG_TRACE(...) (void)0 + #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 + #define SPDLOG_TRACE(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG -# define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) -# define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) + #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 -# define SPDLOG_DEBUG(...) (void)0 + #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 + #define SPDLOG_DEBUG(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO -# define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) -# define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) + #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_INFO(logger, ...) (void)0 -# define SPDLOG_INFO(...) (void)0 + #define SPDLOG_LOGGER_INFO(logger, ...) (void)0 + #define SPDLOG_INFO(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN -# define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) -# define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) + #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_WARN(logger, ...) (void)0 -# define SPDLOG_WARN(...) (void)0 + #define SPDLOG_LOGGER_WARN(logger, ...) (void)0 + #define SPDLOG_WARN(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR -# define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) -# define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) + #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 -# define SPDLOG_ERROR(...) (void)0 + #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 + #define SPDLOG_ERROR(...) (void)0 #endif #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL -# define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) -# define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) + #define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) + #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) #else -# define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 -# define SPDLOG_CRITICAL(...) (void)0 + #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 + #define SPDLOG_CRITICAL(...) (void)0 #endif #ifdef SPDLOG_HEADER_ONLY -# include "spdlog-inl.h" + #include "spdlog-inl.h" #endif #endif // SPDLOG_H diff --git a/include/spdlog/stopwatch.h b/include/spdlog/stopwatch.h index bea7b8a7..0fc3ea37 100644 --- a/include/spdlog/stopwatch.h +++ b/include/spdlog/stopwatch.h @@ -3,8 +3,8 @@ #pragma once -#include #include +#include // Stopwatch support for spdlog (using std::chrono::steady_clock). // Displays elapsed seconds since construction as double. @@ -17,7 +17,8 @@ // spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 seconds" // // -// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use "duration_cast<..>(sw.elapsed())": +// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use +// "duration_cast<..>(sw.elapsed())": // // #include //.. @@ -26,25 +27,17 @@ // spdlog::info("Elapsed {}", duration_cast(sw.elapsed())); => "Elapsed 5ms" namespace spdlog { -class stopwatch -{ +class stopwatch { using clock = std::chrono::steady_clock; std::chrono::time_point start_tp_; public: stopwatch() - : start_tp_{clock::now()} - {} + : start_tp_{clock::now()} {} - std::chrono::duration elapsed() const - { - return std::chrono::duration(clock::now() - start_tp_); - } + std::chrono::duration elapsed() const { return std::chrono::duration(clock::now() - start_tp_); } - void reset() - { - start_tp_ = clock::now(); - } + void reset() { start_tp_ = clock::now(); } }; } // namespace spdlog @@ -57,12 +50,10 @@ namespace #endif { -template<> -struct formatter : formatter -{ - template - auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) - { +template <> +struct formatter : formatter { + template + auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) { return formatter::format(sw.elapsed().count(), ctx); } }; diff --git a/src/async.cpp b/src/async.cpp index 5ea8d8f4..026185ac 100644 --- a/src/async.cpp +++ b/src/async.cpp @@ -2,7 +2,7 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif #include diff --git a/src/bundled_fmtlib_format.cpp b/src/bundled_fmtlib_format.cpp index 93391826..02bb55da 100644 --- a/src/bundled_fmtlib_format.cpp +++ b/src/bundled_fmtlib_format.cpp @@ -3,50 +3,44 @@ // All rights reserved. #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif #if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT) -#include + #include FMT_BEGIN_NAMESPACE namespace detail { -template FMT_API auto dragonbox::to_decimal(float x) noexcept - -> dragonbox::decimal_fp; -template FMT_API auto dragonbox::to_decimal(double x) noexcept - -> dragonbox::decimal_fp; +template FMT_API auto dragonbox::to_decimal(float x) noexcept -> dragonbox::decimal_fp; +template FMT_API auto dragonbox::to_decimal(double x) noexcept -> dragonbox::decimal_fp; -#ifndef FMT_STATIC_THOUSANDS_SEPARATOR -template FMT_API locale_ref::locale_ref(const std::locale& loc); + #ifndef FMT_STATIC_THOUSANDS_SEPARATOR +template FMT_API locale_ref::locale_ref(const std::locale &loc); template FMT_API auto locale_ref::get() const -> std::locale; -#endif + #endif // Explicit instantiations for char. -template FMT_API auto thousands_sep_impl(locale_ref) - -> thousands_sep_result; +template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; template FMT_API auto decimal_point_impl(locale_ref) -> char; -template FMT_API void buffer::append(const char*, const char*); +template FMT_API void buffer::append(const char *, const char *); // DEPRECATED! // There is no correspondent extern template in format.h because of // incompatibility between clang and gcc (#2377). -template FMT_API void vformat_to(buffer&, string_view, - basic_format_args, - locale_ref); +template FMT_API void vformat_to(buffer &, string_view, basic_format_args, locale_ref); // Explicit instantiations for wchar_t. -template FMT_API auto thousands_sep_impl(locale_ref) - -> thousands_sep_result; +template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; -template FMT_API void buffer::append(const wchar_t*, const 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 diff --git a/src/cfg.cpp b/src/cfg.cpp index e5713cca..ebdea166 100644 --- a/src/cfg.cpp +++ b/src/cfg.cpp @@ -2,7 +2,7 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif #include diff --git a/src/color_sinks.cpp b/src/color_sinks.cpp index 38fa308c..1ad1bd66 100644 --- a/src/color_sinks.cpp +++ b/src/color_sinks.cpp @@ -2,18 +2,18 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif #include -#include #include +#include // // color sinks // #ifdef _WIN32 -# include + #include template class SPDLOG_API spdlog::sinks::wincolor_sink; template class SPDLOG_API spdlog::sinks::wincolor_sink; template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; @@ -21,7 +21,7 @@ template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; #else -# include "spdlog/sinks/ansicolor_sink-inl.h" + #include "spdlog/sinks/ansicolor_sink-inl.h" template class SPDLOG_API spdlog::sinks::ansicolor_sink; template class SPDLOG_API spdlog::sinks::ansicolor_sink; template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink; @@ -32,20 +32,20 @@ template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink 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::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::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::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::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::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::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::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); diff --git a/src/file_sinks.cpp b/src/file_sinks.cpp index 10ffba60..04cb6c10 100644 --- a/src/file_sinks.cpp +++ b/src/file_sinks.cpp @@ -2,13 +2,13 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif -#include #include -#include +#include #include +#include #include diff --git a/src/spdlog.cpp b/src/spdlog.cpp index c86d8fff..9c7ae9c4 100644 --- a/src/spdlog.cpp +++ b/src/spdlog.cpp @@ -2,25 +2,26 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif -#include #include #include -#include -#include -#include #include #include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include +#include #include // template instantiate logger constructor with sinks init list -template SPDLOG_API spdlog::logger::logger(std::string name, sinks_init_list::iterator begin, sinks_init_list::iterator end); +template SPDLOG_API +spdlog::logger::logger(std::string name, sinks_init_list::iterator begin, sinks_init_list::iterator end); template class SPDLOG_API spdlog::sinks::base_sink; template class SPDLOG_API spdlog::sinks::base_sink; diff --git a/src/stdout_sinks.cpp b/src/stdout_sinks.cpp index 2d5256a4..df7b6490 100644 --- a/src/stdout_sinks.cpp +++ b/src/stdout_sinks.cpp @@ -2,13 +2,13 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifndef SPDLOG_COMPILED_LIB -# error Please define SPDLOG_COMPILED_LIB to compile this file. + #error Please define SPDLOG_COMPILED_LIB to compile this file. #endif #include -#include #include +#include #include template class SPDLOG_API spdlog::sinks::stdout_sink_base; @@ -18,12 +18,20 @@ template class SPDLOG_API spdlog::sinks::stdout_sink; template class SPDLOG_API spdlog::sinks::stderr_sink; -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); -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);