From 6de0ffa15f2d2304738b9578a57d4707dc5e606e Mon Sep 17 00:00:00 2001 From: gabime Date: Mon, 25 Sep 2023 02:35:55 +0300 Subject: [PATCH] Updated clang format to google style --- .clang-format | 112 +-- include/spdlog/async.h | 46 +- include/spdlog/async_logger.h | 34 +- include/spdlog/cfg/argv.h | 14 +- include/spdlog/cfg/env.h | 8 +- include/spdlog/cfg/helpers.h | 1 - include/spdlog/common.h | 244 +++---- include/spdlog/details/circular_q.h | 78 +- include/spdlog/details/console_globals.h | 14 +- include/spdlog/details/file_helper.h | 3 +- include/spdlog/details/fmt_helper.h | 98 +-- include/spdlog/details/log_msg.h | 3 +- include/spdlog/details/log_msg_buffer.h | 3 +- include/spdlog/details/mpmc_blocking_q.h | 83 +-- include/spdlog/details/null_mutex.h | 25 +- include/spdlog/details/os.h | 22 +- include/spdlog/details/periodic_worker.h | 17 +- include/spdlog/details/registry.h | 10 +- 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.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 | 10 +- include/spdlog/fmt/compile.h | 10 +- include/spdlog/fmt/fmt.h | 10 +- include/spdlog/fmt/ostr.h | 10 +- include/spdlog/fmt/ranges.h | 10 +- include/spdlog/fmt/std.h | 14 +- include/spdlog/fmt/xchar.h | 10 +- include/spdlog/formatter.h | 5 +- include/spdlog/logger.h | 242 +++---- include/spdlog/pattern_formatter.h | 59 +- include/spdlog/sinks/android_sink.h | 96 ++- include/spdlog/sinks/ansicolor_sink.h | 21 +- include/spdlog/sinks/base_sink.h | 5 +- include/spdlog/sinks/basic_file_sink.h | 29 +- 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 | 68 +- include/spdlog/sinks/msvc_sink.h | 19 +- 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 | 37 +- include/spdlog/sinks/rotating_file_sink.h | 44 +- include/spdlog/sinks/sink.h | 4 +- include/spdlog/sinks/stdout_color_sinks.h | 14 +- include/spdlog/sinks/stdout_sinks.h | 27 +- 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 | 125 ++-- include/spdlog/sinks/wincolor_sink.h | 19 +- include/spdlog/spdlog.h | 204 ++---- include/spdlog/stopwatch.h | 31 +- src/async_logger.cpp | 77 +- src/cfg/.helpers.cpp | 49 +- src/common.cpp | 30 +- src/details/file_helper.cpp | 87 +-- src/details/log_msg.cpp | 29 +- src/details/log_msg_buffer.cpp | 20 +- src/details/os.cpp | 346 ++++----- src/details/periodic_worker.cpp | 6 +- src/details/registry.cpp | 143 ++-- src/details/thread_pool.cpp | 95 +-- src/fmt/bundled_fmtlib_format.cpp | 6 +- src/logger.cpp | 118 +--- src/pattern_formatter.cpp | 705 +++++++------------ src/sinks/ansicolor_sink.cpp | 79 +-- src/sinks/base_sink.cpp | 42 +- src/sinks/basic_file_sink.cpp | 24 +- src/sinks/rotating_file_sink.cpp | 82 +-- src/sinks/sink.cpp | 11 +- src/sinks/stdout_color_sinks.cpp | 58 +- src/sinks/stdout_sinks.cpp | 114 ++- src/sinks/wincolor_sink.cpp | 125 ++-- src/spdlog.cpp | 79 +-- 86 files changed, 2164 insertions(+), 3466 deletions(-) diff --git a/.clang-format b/.clang-format index 222faea4..c8769d92 100644 --- a/.clang-format +++ b/.clang-format @@ -1,109 +1,17 @@ --- Language: Cpp -# BasedOnStyle: LLVM +# BasedOnStyle: Google AccessModifierOffset: -4 -AlignAfterOpenBracket: DontAlign -AlignConsecutiveAssignments: false -AlignConsecutiveDeclarations: false -AlignEscapedNewlines: Right -AlignOperands: true -AlignTrailingComments: true -AllowAllParametersOfDeclarationOnNextLine: true -AllowShortBlocksOnASingleLine: true -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: Empty -AllowShortIfStatementsOnASingleLine: false -AllowShortLoopsOnASingleLine: false -AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: None -AlwaysBreakBeforeMultilineStrings: false -AlwaysBreakTemplateDeclarations: true -BinPackArguments: true -BinPackParameters: true -BraceWrapping: - AfterClass: true - AfterControlStatement: true - AfterEnum: true - AfterFunction: true - AfterNamespace: false - AfterObjCDeclaration: true - AfterStruct: true - AfterUnion: true - BeforeCatch: true - BeforeElse: true - IndentBraces: false - SplitEmptyFunction: false - SplitEmptyRecord: false - SplitEmptyNamespace: false -BreakBeforeBinaryOperators: None -BreakBeforeBraces: Custom -BreakBeforeInheritanceComma: false -BreakBeforeTernaryOperators: true -BreakConstructorInitializersBeforeComma: true -BreakConstructorInitializers: BeforeColon -BreakAfterJavaFieldAnnotations: false -BreakStringLiterals: true -ColumnLimit: 140 -CommentPragmas: '^ IWYU pragma:' -CompactNamespaces: false -ConstructorInitializerAllOnOneLineOrOnePerLine: false -ConstructorInitializerIndentWidth: 4 -ContinuationIndentWidth: 4 -Cpp11BracedListStyle: true -DerivePointerAlignment: false -DisableFormat: false -ExperimentalAutoDetectBinPacking: false -FixNamespaceComments: true -ForEachMacros: - - foreach - - Q_FOREACH - - BOOST_FOREACH -IncludeCategories: - - Regex: '^"(llvm|llvm-c|clang|clang-c)/' - Priority: 2 - - Regex: '^(<|"(gtest|gmock|isl|json)/)' - Priority: 3 - - Regex: '.*' - Priority: 1 -IncludeIsMainRegex: '(Test)?$' -IndentCaseLabels: false +Standard: c++17 IndentWidth: 4 -IndentWrappedFunctionNames: false -JavaScriptQuotes: Leave -JavaScriptWrapImports: true -KeepEmptyLinesAtTheStartOfBlocks: true -MacroBlockBegin: '' -MacroBlockEnd: '' -MaxEmptyLinesToKeep: 1 -NamespaceIndentation: None -ObjCBlockIndentWidth: 2 -ObjCSpaceAfterProperty: false -ObjCSpaceBeforeProtocolList: true -PenaltyBreakAssignment: 2 -PenaltyBreakBeforeFirstCallParameter: 19 -PenaltyBreakComment: 300 -PenaltyBreakFirstLessLess: 120 -PenaltyBreakString: 1000 -PenaltyExcessCharacter: 1000000 -PenaltyReturnTypeOnItsOwnLine: 60 -PointerAlignment: Right -ReflowComments: true -SortIncludes: false -SortUsingDeclarations: true -SpaceAfterCStyleCast: false -SpaceAfterTemplateKeyword: false -SpaceBeforeAssignmentOperators: true -SpaceBeforeParens: ControlStatements -SpaceInEmptyParentheses: false -SpacesBeforeTrailingComments: 1 -SpacesInAngles: false -SpacesInContainerLiterals: true -SpacesInCStyleCastParentheses: false -SpacesInParentheses: false -SpacesInSquareBrackets: false -Standard: Cpp11 -TabWidth: 8 +TabWidth: 4 UseTab: Never -IndentPPDirectives: AfterHash +ColumnLimit: 120 +AlignAfterOpenBracket: Align +BinPackParameters: false +AlignEscapedNewlines: Left +AlwaysBreakTemplateDeclarations: Yes +PackConstructorInitializers: Never +IndentPPDirectives: BeforeHash ... 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.h b/include/spdlog/async_logger.h index 52866fbb..22fc38d5 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; 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.h b/include/spdlog/cfg/helpers.h index fb196f7a..74d66c09 100644 --- a/include/spdlog/cfg/helpers.h +++ b/include/spdlog/cfg/helpers.h @@ -20,6 +20,5 @@ namespace helpers { // SPDLOG_API void load_levels(const std::string &txt); } // namespace helpers - } // namespace cfg } // namespace spdlog diff --git a/include/spdlog/common.h b/include/spdlog/common.h index df1a80dc..97f92b38 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -2,85 +2,84 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #pragma once -#include #include +#include +#include #include #include +#include +#include +#include +#include #include #include -#include #include #include -#include -#include -#include -#include #if __has_include() -# include + #include #endif #if __cpp_lib_source_location >= 201907 -# include -# define SPDLOG_HAVE_STD_SOURCE_LOCATION + #include + #define SPDLOG_HAVE_STD_SOURCE_LOCATION #elif __has_include() -# include -# define SPDLOG_HAVE_EXPERIMENTAL_SOURCE_LOCATION + #include + #define SPDLOG_HAVE_EXPERIMENTAL_SOURCE_LOCATION #endif #ifdef SPDLOG_USE_STD_FORMAT -# if __cpp_lib_format >= 202207L -# include -# else -# include -# endif + #if __cpp_lib_format >= 202207L + #include + #else + #include + #endif #endif #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 + #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 + #define SPDLOG_API #endif #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) -# if defined(SPDLOG_WCHAR_FILENAMES) -# include -# endif + #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) + #if defined(SPDLOG_WCHAR_FILENAMES) + #include + #endif #else -# define SPDLOG_FMT_RUNTIME(format_string) format_string + #define SPDLOG_FMT_RUNTIME(format_string) format_string #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 { @@ -93,12 +92,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; @@ -113,24 +112,24 @@ using memory_buf_t = std::string; 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 format_string_t = std::format_string; -# else + #else using format_string_t = std::string_view; -# endif + #endif -# define SPDLOG_BUF_TO_STRING(x) x + #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; using wstring_view_t = fmt::basic_string_view; using wmemory_buf_t = fmt::basic_memory_buffer; -# define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) + #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) #endif // SPDLOG_USE_STD_FORMAT #define SPDLOG_LEVEL_TRACE 0 @@ -142,16 +141,15 @@ using wmemory_buf_t = fmt::basic_memory_buffer; #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 // Is convertable to string_view_t ? -template +template using is_convertible_to_sv = std::enable_if_t>; // Log level enum -enum class level -{ +enum class level { trace = SPDLOG_LEVEL_TRACE, debug = SPDLOG_LEVEL_DEBUG, info = SPDLOG_LEVEL_INFO, @@ -169,34 +167,25 @@ using atomic_level_t = std::atomic; #endif #if !defined(SPDLOG_LEVEL_NAMES) -# define SPDLOG_LEVEL_NAMES \ - { \ - "trace", "debug", "info", "warning", "error", "critical", "off" \ - } + #define SPDLOG_LEVEL_NAMES \ + { "trace", "debug", "info", "warning", "error", "critical", "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 -[[nodiscard]] constexpr size_t level_to_number(level lvl) noexcept -{ - return static_cast(lvl); -} +[[nodiscard]] constexpr size_t level_to_number(level lvl) noexcept { return static_cast(lvl); } constexpr auto levels_count = level_to_number(level::n_levels); constexpr std::array level_string_views SPDLOG_LEVEL_NAMES; constexpr std::array short_level_names SPDLOG_SHORT_LEVEL_NAMES; -[[nodiscard]] constexpr string_view_t to_string_view(spdlog::level lvl) noexcept -{ +[[nodiscard]] constexpr string_view_t to_string_view(spdlog::level lvl) noexcept { return level_string_views.at(level_to_number(lvl)); } -[[nodiscard]] constexpr const char *to_short_c_str(spdlog::level lvl) noexcept -{ +[[nodiscard]] constexpr const char *to_short_c_str(spdlog::level lvl) noexcept { return short_level_names.at(level_to_number(lvl)); } @@ -205,19 +194,13 @@ SPDLOG_API [[nodiscard]] spdlog::level level_from_str(const std::string &name) n // // 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 }; @@ -225,8 +208,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); @@ -239,37 +221,27 @@ 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 { constexpr source_loc() = default; constexpr source_loc(const char *filename_in, std::uint_least32_t line_in, const char *funcname_in) - : filename{filename_in} - , line{line_in} - , funcname{funcname_in} - {} + : filename{filename_in}, + line{line_in}, + funcname{funcname_in} {} #ifdef SPDLOG_HAVE_STD_SOURCE_LOCATION - static constexpr source_loc current(const std::source_location source_location = std::source_location::current()) - { + static constexpr source_loc current(const std::source_location source_location = std::source_location::current()) { return source_loc{source_location.file_name(), source_location.line(), source_location.function_name()}; } #elif defined(SPDLOG_HAVE_EXPERIMENTAL_SOURCE_LOCATION) - static constexpr source_loc current( - const std::experimental::source_location source_location = std::experimental::source_location::current()) - { + static constexpr source_loc + current(const std::experimental::source_location source_location = std::experimental::source_location::current()) { return source_loc{source_location.file_name(), source_location.line(), source_location.function_name()}; } #else // no source location support - static constexpr source_loc current() - { - return source_loc{}; - } + static constexpr source_loc current() { return source_loc{}; } #endif - [[nodiscard]] constexpr bool empty() const noexcept - { - return line == 0; - } + [[nodiscard]] constexpr bool empty() const noexcept { return line == 0; } const char *filename{nullptr}; std::uint_least32_t line{0}; const char *funcname{nullptr}; @@ -277,32 +249,27 @@ struct source_loc // trick to capture format string and caller's source location with variadic template. // see logger::info() etc. to understand how it's used. -struct loc_with_fmt -{ +struct loc_with_fmt { source_loc loc; string_view_t fmt_string; - template> + template > constexpr loc_with_fmt(S fmt_str, source_loc loc = source_loc::current()) noexcept - : loc(loc) - , fmt_string(fmt_str) - {} + : loc(loc), + fmt_string(fmt_str) {} #ifndef SPDLOG_USE_STD_FORMAT constexpr loc_with_fmt(fmt::runtime_format_string fmt_str, source_loc loc = source_loc::current()) noexcept - : loc(loc) - , fmt_string(fmt_str.str) - {} + : loc(loc), + fmt_string(fmt_str.str) {} #endif }; -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; @@ -314,47 +281,36 @@ namespace details { // to_string_view -[[nodiscard]] constexpr spdlog::string_view_t to_string_view(const memory_buf_t &buf) noexcept -{ +[[nodiscard]] constexpr spdlog::string_view_t to_string_view(const memory_buf_t &buf) noexcept { return spdlog::string_view_t{buf.data(), buf.size()}; } -[[nodiscard]] constexpr spdlog::string_view_t to_string_view(spdlog::string_view_t str) noexcept -{ - return str; -} +[[nodiscard]] constexpr spdlog::string_view_t to_string_view(spdlog::string_view_t str) noexcept { return str; } #if defined(SPDLOG_WCHAR_FILENAMES) -[[nodiscard]] constexpr spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) noexcept -{ +[[nodiscard]] constexpr spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) noexcept { return spdlog::wstring_view_t{buf.data(), buf.size()}; } -[[nodiscard]] constexpr spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) noexcept -{ - return str; -} +[[nodiscard]] constexpr spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) noexcept { return str; } #endif // convert format_string<...> to string_view depending on format lib versions #if defined(SPDLOG_USE_STD_FORMAT) -# if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L -template -[[nodiscard]] constexpr std::basic_string_view to_string_view(std::basic_format_string fmt) noexcept -{ + #if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L +template +[[nodiscard]] constexpr std::basic_string_view to_string_view(std::basic_format_string fmt) noexcept { return fmt.get(); } -# else // std::format and __cpp_lib_format < 202207L -template -[[nodiscard]] constexpr std::basic_string_view to_string_view(std::basic_format_string fmt) noexcept -{ + #else // std::format and __cpp_lib_format < 202207L +template +[[nodiscard]] constexpr std::basic_string_view to_string_view(std::basic_format_string fmt) noexcept { return fmt; } -# endif + #endif #else // {fmt} version -template -[[nodiscard]] constexpr fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) noexcept -{ +template +[[nodiscard]] constexpr fmt::basic_string_view to_string_view(fmt::basic_format_string fmt) noexcept { return fmt; } #endif diff --git a/include/spdlog/details/circular_q.h b/include/spdlog/details/circular_q.h index 6c812171..b030e65f 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) noexcept - { - copy_moveable(std::move(other)); - } + circular_q(circular_q &&other) noexcept { copy_moveable(std::move(other)); } - circular_q &operator=(circular_q &&other) noexcept - { + circular_q &operator=(circular_q &&other) 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,78 +56,53 @@ public: // Return const reference to the front item. // If there are no elements in the container, the behavior is undefined. - [[nodiscard]] const T &front() const - { - return v_[head_]; - } + [[nodiscard]] const T &front() const { return v_[head_]; } // Return reference to the front item. // If there are no elements in the container, the behavior is undefined. - [[nodiscard]] T &front() - { - return v_[head_]; - } + [[nodiscard]] T &front() { return v_[head_]; } // Return number of elements actually stored - [[nodiscard]] size_t size() const - { - if (tail_ >= head_) - { + [[nodiscard]] 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 &operator[](size_t idx) const - { + const T &operator[](size_t idx) const { assert(idx < size()); assert(max_items_ > 0); return v_[(head_ + idx) % max_items_]; } // Pop item from front if not empty. - void pop_front() - { - if (!empty()) - { + void pop_front() { + if (!empty()) { head_ = (head_ + 1) % max_items_; } } - [[nodiscard]] bool empty() const - { - return tail_ == head_; - } + [[nodiscard]] bool empty() const { return tail_ == head_; } - [[nodiscard]] bool full() const - { + [[nodiscard]] 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 true; } - [[nodiscard]] size_t overrun_counter() const - { - return overrun_counter_; - } + [[nodiscard]] 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) noexcept - { + void copy_moveable(circular_q &&other) 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.h b/include/spdlog/details/file_helper.h index fbed2fb3..db4a9b03 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); diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h index 1a89d700..be00f676 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 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 -constexpr unsigned int count_digits_fallback(T n) -{ +template +constexpr 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 @@ constexpr 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), "{: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.h b/include/spdlog/details/log_msg.h index ea868530..d2ffe6fd 100644 --- a/include/spdlog/details/log_msg.h +++ b/include/spdlog/details/log_msg.h @@ -8,8 +8,7 @@ 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 lvl, string_view_t msg); log_msg(source_loc loc, string_view_t logger_name, level lvl, string_view_t msg); diff --git a/include/spdlog/details/log_msg_buffer.h b/include/spdlog/details/log_msg_buffer.h index 762f4ff6..f8492e3e 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(); 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 37a7e3c5..aee2e2f4 100644 --- a/include/spdlog/details/null_mutex.h +++ b/include/spdlog/details/null_mutex.h @@ -9,37 +9,26 @@ // null, no cost dummy "mutex" and dummy "atomic" log level namespace spdlog { - namespace details { -struct null_mutex -{ +struct null_mutex { void lock() const {} void unlock() const {} }; -template -struct null_atomic -{ +template +struct null_atomic { T value; null_atomic() = default; explicit constexpr null_atomic(T new_value) - : value(new_value) - {} + : value(new_value) {} - [[nodiscard]] T load(std::memory_order = std::memory_order_seq_cst) const - { - return value; - } + [[nodiscard]] T load(std::memory_order = std::memory_order_seq_cst) const { return value; } - void store(T new_value, std::memory_order = std::memory_order_seq_cst) - { - value = new_value; - } + void store(T new_value, std::memory_order = std::memory_order_seq_cst) { value = new_value; } - T exchange(T new_value, std::memory_order = std::memory_order_seq_cst) - { + T exchange(T new_value, std::memory_order = std::memory_order_seq_cst) { std::swap(new_value, value); return new_value; // return value before the call } diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h index a9da48a7..17c0f9c8 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() 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 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 constexpr static const char folder_seps[] = SPDLOG_FOLDER_SEPS; diff --git a/include/spdlog/details/periodic_worker.h b/include/spdlog/details/periodic_worker.h index 451f3192..5b0cda00 100644 --- a/include/spdlog/details/periodic_worker.h +++ b/include/spdlog/details/periodic_worker.h @@ -20,24 +20,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(); diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index 1046cfe3..70615fd2 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; @@ -57,9 +56,8 @@ public: void flush_on(level 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_ = std::make_unique(clbk, interval); 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.h b/include/spdlog/details/thread_pool.h index f1a4a0b3..dceb15c8 100644 --- a/include/spdlog/details/thread_pool.h +++ b/include/spdlog/details/thread_pool.h @@ -3,16 +3,16 @@ #pragma once +#include #include #include #include -#include #include +#include #include #include #include -#include namespace spdlog { class async_logger; @@ -21,17 +21,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; @@ -44,13 +38,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); @@ -63,29 +55,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); 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 4f3dad74..15216f9e 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 - constexpr auto parse(ParseContext &ctx) -> decltype(ctx.begin()) - { + template + constexpr 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()) { constexpr const char *hex_upper = "0123456789ABCDEF"; 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, "{:04X}: ", pos); } } diff --git a/include/spdlog/fmt/chrono.h b/include/spdlog/fmt/chrono.h index 1cab3b74..e991b775 100644 --- a/include/spdlog/fmt/chrono.h +++ b/include/spdlog/fmt/chrono.h @@ -9,9 +9,9 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/compile.h b/include/spdlog/fmt/compile.h index a82c7255..150be096 100644 --- a/include/spdlog/fmt/compile.h +++ b/include/spdlog/fmt/compile.h @@ -9,9 +9,9 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/fmt.h b/include/spdlog/fmt/fmt.h index 94295766..2ef740d5 100644 --- a/include/spdlog/fmt/fmt.h +++ b/include/spdlog/fmt/fmt.h @@ -11,11 +11,11 @@ // #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format -# include + #include #elif !defined(SPDLOG_FMT_EXTERNAL) -# 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 6ca7a89a..dbb159d2 100644 --- a/include/spdlog/fmt/ostr.h +++ b/include/spdlog/fmt/ostr.h @@ -9,9 +9,9 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/ranges.h b/include/spdlog/fmt/ranges.h index a8094843..f3971363 100644 --- a/include/spdlog/fmt/ranges.h +++ b/include/spdlog/fmt/ranges.h @@ -9,9 +9,9 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/std.h b/include/spdlog/fmt/std.h index c8edc45d..854b6254 100644 --- a/include/spdlog/fmt/std.h +++ b/include/spdlog/fmt/std.h @@ -5,14 +5,14 @@ #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) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #include + #else + #include + #endif #endif diff --git a/include/spdlog/fmt/xchar.h b/include/spdlog/fmt/xchar.h index 0a5f4d5f..fd15f070 100644 --- a/include/spdlog/fmt/xchar.h +++ b/include/spdlog/fmt/xchar.h @@ -9,9 +9,9 @@ // #if !defined(SPDLOG_USE_STD_FORMAT) -# if !defined(SPDLOG_FMT_EXTERNAL) -# include -# else -# include -# endif + #if !defined(SPDLOG_FMT_EXTERNAL) + #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.h b/include/spdlog/logger.h index 38fd40a3..e617e700 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -18,57 +18,47 @@ #include #include -#include #include +#include #ifndef SPDLOG_NO_EXCEPTIONS -# define SPDLOG_LOGGER_CATCH(location) \ - catch (const std::exception &ex) \ - { \ - if (!location.empty()) \ - { \ - err_handler_(fmt_lib::format("{} [{}({})]", 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.empty()) { \ + err_handler_(fmt_lib::format("{} [{}({})]", 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)) - {} + : name_(std::move(name)) {} // 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()) {} logger(const logger &other) noexcept; logger(logger &&other) noexcept; @@ -76,201 +66,138 @@ public: virtual ~logger() = default; // log functions - template - void log(source_loc loc, level lvl, format_string_t fmt, Args &&...args) - { - if (should_log(lvl)) - { + template + void log(source_loc loc, level lvl, format_string_t fmt, Args &&...args) { + if (should_log(lvl)) { log_with_format_(loc, lvl, details::to_string_view(fmt), std::forward(args)...); } } - template - void log(level lvl, format_string_t fmt, Args &&...args) - { - if (should_log(lvl)) - { + template + void log(level lvl, format_string_t fmt, Args &&...args) { + if (should_log(lvl)) { log_with_format_(source_loc{}, lvl, details::to_string_view(fmt), std::forward(args)...); } } - template, typename... Args> - void log(source_loc loc, level lvl, S fmt, Args &&...args) - { - if (should_log(lvl)) - { + template , typename... Args> + void log(source_loc loc, level lvl, S fmt, Args &&...args) { + if (should_log(lvl)) { log_with_format_(loc, lvl, fmt, std::forward(args)...); } } // log with no format string, just string message - void log(source_loc loc, level lvl, string_view_t msg) - { - if (should_log(lvl)) - { + void log(source_loc loc, level lvl, string_view_t msg) { + if (should_log(lvl)) { sink_it_(details::log_msg(loc, name_, lvl, msg)); } } - void log(level lvl, string_view_t msg) - { - if (should_log(lvl)) - { + void log(level lvl, string_view_t msg) { + if (should_log(lvl)) { sink_it_(details::log_msg(source_loc{}, name_, lvl, msg)); } } // support for custom time - void log(log_clock::time_point log_time, source_loc loc, level lvl, string_view_t msg) - { - if (should_log(lvl)) - { + void log(log_clock::time_point log_time, source_loc loc, level lvl, string_view_t msg) { + if (should_log(lvl)) { sink_it_(details::log_msg(log_time, loc, name_, lvl, msg)); } } #ifdef SPDLOG_SOURCE_LOCATION - template - void trace(loc_with_fmt fmt, Args &&...args) - { + template + void trace(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::trace, fmt.fmt_string, std::forward(args)...); } - template - void debug(loc_with_fmt fmt, Args &&...args) - { + template + void debug(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::debug, fmt.fmt_string, std::forward(args)...); } - template - void info(loc_with_fmt fmt, Args &&...args) - { + template + void info(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::info, fmt.fmt_string, std::forward(args)...); } - template - void warn(loc_with_fmt fmt, Args &&...args) - { + template + void warn(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::warn, fmt.fmt_string, std::forward(args)...); } - template - void error(loc_with_fmt fmt, Args &&...args) - { + template + void error(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::err, fmt.fmt_string, std::forward(args)...); } - template - void critical(loc_with_fmt fmt, Args &&...args) - { + template + void critical(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::critical, fmt.fmt_string, std::forward(args)...); } // log functions with no format string, just string - void trace(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::trace, msg); - } + void trace(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::trace, msg); } - void debug(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::debug, msg); - } + void debug(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::debug, msg); } - void info(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::info, msg); - } + void info(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::info, msg); } - void warn(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::warn, msg); - } + void warn(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::warn, msg); } - void error(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::err, msg); - } + void error(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::err, msg); } - void critical(string_view_t msg, source_loc loc = source_loc::current()) - { - log(loc, level::critical, msg); - } + void critical(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::critical, msg); } #else - 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)...); } // log functions with no format string, just string - void trace(string_view_t msg) - { - log(level::trace, msg); - } + void trace(string_view_t msg) { log(level::trace, msg); } - void debug(string_view_t msg) - { - log(level::debug, msg); - } + void debug(string_view_t msg) { log(level::debug, msg); } - void info(string_view_t msg) - { - log(level::info, msg); - } + void info(string_view_t msg) { log(level::info, msg); } - inline void warn(string_view_t msg) - { - log(level::warn, msg); - } + inline void warn(string_view_t msg) { log(level::warn, msg); } - void error(string_view_t msg) - { - log(level::err, msg); - } + void error(string_view_t msg) { log(level::err, msg); } - void critical(string_view_t msg) - { - log(level::critical, msg); - } + void critical(string_view_t msg) { log(level::critical, msg); } #endif // return true if logging is enabled for the given level. - [[nodiscard]] bool should_log(level msg_level) const - { - return msg_level >= level_.load(std::memory_order_relaxed); - } + [[nodiscard]] bool should_log(level msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } // set the level of logging void set_level(level level); @@ -315,12 +242,10 @@ protected: err_handler custom_err_handler_{nullptr}; // common implementation for after templated public api has been resolved to format string and args - template - void log_with_format_(source_loc loc, level lvl, string_view_t fmt, Args &&...args) - { + template + void log_with_format_(source_loc loc, level lvl, string_view_t fmt, Args &&...args) { assert(should_log(lvl)); - SPDLOG_TRY - { + SPDLOG_TRY { #ifdef SPDLOG_USE_STD_FORMAT auto formatted = std::vformat(fmt, std::make_format_args(args...)); sink_it_(details::log_msg(loc, name_, lvl, formatted)); @@ -334,23 +259,16 @@ protected: } // log the given message (if the given log level is high enough) - virtual void sink_it_(const details::log_msg &msg) - { + virtual void sink_it_(const details::log_msg &msg) { assert(should_log(msg.log_level)); - for (auto &sink : sinks_) - { - if (sink->should_log(msg.log_level)) - { - SPDLOG_TRY - { - sink->log(msg); - } + for (auto &sink : sinks_) { + if (sink->should_log(msg.log_level)) { + SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } - if (should_flush_(msg)) - { + if (should_flush_(msg)) { flush_(); } } diff --git a/include/spdlog/pattern_formatter.h b/include/spdlog/pattern_formatter.h index 1623bfac..45bd2a78 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] = std::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) diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h index 34480ba0..6db9a359 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.log_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) - { - switch (level) - { + static android_LogPriority convert_to_android_(spdlog::level 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.h b/include/spdlog/sinks/ansicolor_sink.h index 9b500f33..c0dc567b 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); }; diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h index 0660f7a3..fd17acd4 100644 --- a/include/spdlog/sinks/base_sink.h +++ b/include/spdlog/sinks/base_sink.h @@ -15,9 +15,8 @@ namespace spdlog { namespace sinks { -template -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); diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h index ae7c4e9e..1903da44 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,17 +40,19 @@ 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); } 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 7dc31501..4436193e 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_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_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 394ae9c3..176a93ef 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.log_level)) - { + void sink_it_(const details::log_msg &msg) override { + for (auto &sub_sink : sinks_) { + if (sub_sink->should_log(msg.log_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_(std::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 c70b00c6..be7c350d 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 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 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 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 4a28f00b..9c3f3edc 100644 --- a/include/spdlog/sinks/mongo_sink.h +++ b/include/spdlog/sinks/mongo_sink.h @@ -25,50 +25,42 @@ 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::std::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) - { + if (client_ != nullptr) { auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" - << level::to_string_view(msg.log_level).data() << "level_num" << msg.log_level << "message" - << std::string(msg.payload.begin(), msg.payload.end()) << "logger_name" + << level::to_string_view(msg.log_level).data() << "level_num" << msg.log_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()); @@ -91,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 8d52a2c5..65b2dc3f 100644 --- a/include/spdlog/sinks/msvc_sink.h +++ b/include/spdlog/sinks/msvc_sink.h @@ -5,11 +5,11 @@ #if defined(_WIN32) -# include -# include + #include + #include -# include -# include + #include + #include // Avoid including windows.h (https://stackoverflow.com/a/30741042) extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); @@ -20,19 +20,16 @@ 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; 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 34499cd3..815dfd75 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 color_level, QTextCharFormat format) - { + void set_level_color(level color_level, QTextCharFormat format) { // std::lock_guard lock(base_sink::mutex_); colors_.at(static_cast(color_level)) = format; } - QTextCharFormat &get_level_color(level color_level) - { + QTextCharFormat &get_level_color(level 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.log_level), // color to apply - color_range_start, // color range start - color_range_end}; // color range end + invoke_params params{max_lines_, // max lines + qt_text_edit_, // text edit to append to + std::move(payload), // text to append + default_color_, // default color + colors_.at(msg.log_level), // color to apply + color_range_start, // color range start + color_range_end}; // color range end QMetaObject::invokeMethod( qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); @@ -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 cbb58215..e7f13f6e 100644 --- a/include/spdlog/sinks/ringbuffer_sink.h +++ b/include/spdlog/sinks/ringbuffer_sink.h @@ -3,50 +3,42 @@ #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 #include #include -#include namespace spdlog { namespace sinks { /* - * Ring buffer sink. Holds fixed amount of log messages in memory. When the buffer is full, new messages override the old ones. - * Useful for storing debug data in memory in case of error. - * Example: - * auto rb_sink = std::make_shared(128); - * spdlog::logger logger("rb_logger", rb_sink); + * Ring buffer sink. Holds fixed amount of log messages in memory. When the buffer is full, new messages override the + * old ones. Useful for storing debug data in memory in case of error. Example: auto rb_sink = + * std::make_shared(128); spdlog::logger logger("rb_logger", rb_sink); * rb->drain([](const std::string_view msg) { process(msg);}); */ -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} {} - void drain_raw(std::function callback) - { + void drain_raw(std::function callback) { std::lock_guard lock(base_sink::mutex_); - while (!q_.empty()) - { + while (!q_.empty()) { callback(q_.front()); q_.pop_front(); } } - void drain(std::function callback) - { + void drain(std::function callback) { std::lock_guard lock(base_sink::mutex_); memory_buf_t formatted; - while (!q_.empty()) - { + while (!q_.empty()) { formatted.clear(); base_sink::formatter_->format(q_.front(), formatted); callback(std::string_view(formatted.data(), formatted.size())); @@ -55,10 +47,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.h b/include/spdlog/sinks/rotating_file_sink.h index b35041cf..7d8b36d7 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,19 +61,25 @@ 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 diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index fb74477d..7e9987d9 100644 --- a/include/spdlog/sinks/sink.h +++ b/include/spdlog/sinks/sink.h @@ -7,10 +7,8 @@ #include 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; diff --git a/include/spdlog/sinks/stdout_color_sinks.h b/include/spdlog/sinks/stdout_color_sinks.h index 27cd0571..a5e70cc4 100644 --- a/include/spdlog/sinks/stdout_color_sinks.h +++ b/include/spdlog/sinks/stdout_color_sinks.h @@ -4,13 +4,13 @@ #pragma once #ifdef _WIN32 -# include + #include #else -# include + #include #endif -#include #include +#include namespace spdlog { namespace sinks { @@ -29,16 +29,16 @@ using stderr_color_sink_st = ansicolor_stderr_sink_st; // template instantations -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 diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index c630683a..b19c96c7 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,16 +65,16 @@ 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 diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index 66b294cb..a7ba00ea 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.log_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 ed44c991..cec2e8d4 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.log_level), + err = (sd_journal_send)("MESSAGE=%.*s", static_cast(length), payload.data(), "PRIORITY=%d", + syslog_level(msg.log_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.log_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.log_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 l) - { - return syslog_levels_.at(static_cast(l)); - } + int syslog_level(level 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 11ecec51..d834e602 100644 --- a/include/spdlog/sinks/win_eventlog_sink.h +++ b/include/spdlog/sinks/win_eventlog_sink.h @@ -47,41 +47,34 @@ namespace win_eventlog { namespace internal { -struct local_alloc_t -{ +struct local_alloc_t { HLOCAL hlocal_; constexpr local_alloc_t() noexcept - : hlocal_(nullptr) - {} + : hlocal_(nullptr) {} local_alloc_t(local_alloc_t const &) = delete; local_alloc_t &operator=(local_alloc_t const &) = delete; - ~local_alloc_t() noexcept - { - if (hlocal_) - { + ~local_alloc_t() 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_); } @@ -89,23 +82,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"); } @@ -113,8 +102,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")); } @@ -122,44 +110,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")); } @@ -168,12 +145,9 @@ public: } }; -struct eventlog -{ - static WORD get_event_type(details::log_msg const &msg) - { - switch (msg.log_level) - { +struct eventlog { + static WORD get_event_type(details::log_msg const &msg) { + switch (msg.log_level) { case level::trace: case level::debug: return EVENTLOG_SUCCESS; @@ -194,10 +168,7 @@ struct eventlog } } - static WORD get_event_category(details::log_msg const &msg) - { - return (WORD)msg.log_level; - } + static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.log_level; } }; } // namespace internal @@ -205,22 +176,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")); } } @@ -229,8 +196,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; @@ -239,11 +205,11 @@ protected: formatted.push_back('\0'); 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)); - if (!succeeded) - { + if (!succeeded) { SPDLOG_THROW(win32_error("ReportEvent")); } } @@ -252,22 +218,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.h b/include/spdlog/sinks/wincolor_sink.h index 1a8a95f7..4784fe0f 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); }; diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 94bfc8a4..aac984b4 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)...); } @@ -72,9 +71,8 @@ SPDLOG_API void flush_on(level 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); } @@ -131,164 +129,112 @@ 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 lvl, format_string_t fmt, Args &&...args) -{ +template +inline void log(source_loc source, level lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); } -template -inline void log(level lvl, format_string_t fmt, Args &&...args) -{ +template +inline void log(level lvl, format_string_t fmt, Args &&...args) { default_logger_raw()->log(lvl, fmt, std::forward(args)...); } -template, typename... Args> -inline void log(source_loc loc, level lvl, S fmt, Args &&...args) -{ +template , typename... Args> +inline void log(source_loc loc, level lvl, S fmt, Args &&...args) { default_logger_raw()->log(loc, lvl, fmt, std::forward(args)...); } -template, typename... Args> -inline void log(level lvl, S fmt, Args &&...args) -{ +template , typename... Args> +inline void log(level lvl, S fmt, Args &&...args) { default_logger_raw()->log(lvl, fmt, std::forward(args)...); } #ifdef SPDLOG_SOURCE_LOCATION -template -inline void trace(loc_with_fmt fmt, Args &&...args) -{ +template +inline void trace(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::trace, fmt.fmt_string, std::forward(args)...); } -template -inline void debug(loc_with_fmt fmt, Args &&...args) -{ +template +inline void debug(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::debug, fmt.fmt_string, std::forward(args)...); } -template -inline void info(loc_with_fmt fmt, Args &&...args) -{ +template +inline void info(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::info, fmt.fmt_string, std::forward(args)...); } -template -inline void warn(loc_with_fmt fmt, Args &&...args) -{ +template +inline void warn(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, spdlog::level::warn, fmt.fmt_string, std::forward(args)...); } -template -inline void error(loc_with_fmt fmt, Args &&...args) -{ +template +inline void error(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::err, fmt.fmt_string, std::forward(args)...); } -template -inline void critical(loc_with_fmt fmt, Args &&...args) -{ +template +inline void critical(loc_with_fmt fmt, Args &&...args) { log(fmt.loc, level::critical, fmt.fmt_string, std::forward(args)...); } // log functions with no format string, just string -inline void trace(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, level::trace, msg); -} +inline void trace(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::trace, msg); } -inline void debug(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, level::debug, msg); -} +inline void debug(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::debug, msg); } -inline void info(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, level::info, msg); -} +inline void info(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::info, msg); } -inline void warn(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, spdlog::level::warn, msg); -} +inline void warn(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, spdlog::level::warn, msg); } -inline void error(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, level::err, msg); -} +inline void error(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::err, msg); } -inline void critical(string_view_t msg, source_loc loc = source_loc::current()) -{ - log(loc, level::critical, msg); -} +inline void critical(string_view_t msg, source_loc loc = source_loc::current()) { log(loc, level::critical, msg); } #else -template -inline void trace(format_string_t fmt, Args &&...args) -{ +template +inline void trace(format_string_t fmt, Args &&...args) { log(level::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) { log(level::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) { log(level::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) { log(level::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) { log(level::err, fmt, std::forward(args)...); } -template -inline void critical(format_string_t fmt, Args &&...args) -{ +template +inline void critical(format_string_t fmt, Args &&...args) { log(level::critical, fmt, std::forward(args)...); } // log functions with no format string, just string -inline void trace(string_view_t msg) -{ - log(level::trace, msg); -} +inline void trace(string_view_t msg) { log(level::trace, msg); } -inline void debug(string_view_t msg) -{ - log(level::debug, msg); -} +inline void debug(string_view_t msg) { log(level::debug, msg); } -inline void info(string_view_t msg) -{ - log(level::info, msg); -} +inline void info(string_view_t msg) { log(level::info, msg); } -inline void warn(string_view_t msg) -{ - log(level::warn, msg); -} +inline void warn(string_view_t msg) { log(level::warn, msg); } -inline void error(string_view_t msg) -{ - log(level::err, msg); -} +inline void error(string_view_t msg) { log(level::err, msg); } -inline void critical(string_view_t msg) -{ - log(level::critical, msg); -} +inline void critical(string_view_t msg) { log(level::critical, msg); } #endif } // namespace spdlog @@ -307,58 +253,58 @@ inline void critical(string_view_t msg) // #ifdef SPDLOG_SOURCE_LOCATION -# 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 #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_logger.cpp b/src/async_logger.cpp index 0904cf5d..4745d502 100644 --- a/src/async_logger.cpp +++ b/src/async_logger.cpp @@ -2,33 +2,30 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #include -#include #include +#include #include #include -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::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::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::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 -void spdlog::async_logger::sink_it_(const details::log_msg &msg) -{ - SPDLOG_TRY - { - if (auto pool_ptr = thread_pool_.lock()) - { +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 - { + } else { throw_spdlog_ex("async log: thread pool doesn't exist anymore"); } } @@ -36,16 +33,11 @@ void spdlog::async_logger::sink_it_(const details::log_msg &msg) } // send flush request to the thread pool -void spdlog::async_logger::flush_() -{ - SPDLOG_TRY - { - if (auto pool_ptr = thread_pool_.lock()) - { +void spdlog::async_logger::flush_() { + SPDLOG_TRY { + if (auto pool_ptr = thread_pool_.lock()) { pool_ptr->post_flush(shared_from_this(), overflow_policy_); - } - else - { + } else { throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); } } @@ -55,40 +47,27 @@ void spdlog::async_logger::flush_() // // backend functions - called from the thread pool to do the actual job // -void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) -{ - for (auto &sink : sinks_) - { - if (sink->should_log(msg.log_level)) - { - SPDLOG_TRY - { - sink->log(msg); - } +void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { + for (auto &sink : sinks_) { + if (sink->should_log(msg.log_level)) { + SPDLOG_TRY { sink->log(msg); } SPDLOG_LOGGER_CATCH(msg.source) } } - if (should_flush_(msg)) - { + if (should_flush_(msg)) { backend_flush_(); } } -void spdlog::async_logger::backend_flush_() -{ - for (auto &sink : sinks_) - { - SPDLOG_TRY - { - sink->flush(); - } +void spdlog::async_logger::backend_flush_() { + for (auto &sink : sinks_) { + SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } -std::shared_ptr spdlog::async_logger::clone(std::string new_name) -{ +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/src/cfg/.helpers.cpp b/src/cfg/.helpers.cpp index 9ee8c832..86976736 100644 --- a/src/cfg/.helpers.cpp +++ b/src/cfg/.helpers.cpp @@ -2,29 +2,27 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #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)); @@ -38,16 +36,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); } @@ -56,15 +50,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); @@ -73,10 +64,8 @@ inline std::unordered_map extract_key_vals_(const std: return rv; } -void load_levels(const std::string &input) -{ - if (input.empty() || input.size() > 512) - { +void load_levels(const std::string &input) { + if (input.empty() || input.size() > 512) { return; } @@ -85,23 +74,19 @@ void load_levels(const std::string &input) level global_level = level::info; bool global_level_found = false; - for (auto &name_level : key_vals) - { + for (auto &name_level : key_vals) { const 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/src/common.cpp b/src/common.cpp index c6034dd9..f8458433 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -8,30 +8,25 @@ namespace spdlog { -spdlog::level level_from_str(const std::string &name) noexcept -{ +spdlog::level level_from_str(const std::string &name) 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 spdlog::level::warn; } - if (name == "err") - { + if (name == "err") { return level::err; } return level::off; } spdlog_ex::spdlog_ex(std::string msg) - : msg_(std::move(msg)) -{} + : msg_(std::move(msg)) {} -spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) -{ +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 @@ -41,19 +36,10 @@ spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) #endif } -const char *spdlog_ex::what() const noexcept -{ - return msg_.c_str(); -} +const char *spdlog_ex::what() const noexcept { return msg_.c_str(); } -void throw_spdlog_ex(const std::string &msg, int last_errno) -{ - SPDLOG_THROW(spdlog_ex(msg, last_errno)); -} +void throw_spdlog_ex(const std::string &msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); } -void throw_spdlog_ex(std::string msg) -{ - SPDLOG_THROW(spdlog_ex(std::move(msg))); -} +void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } } // namespace spdlog diff --git a/src/details/file_helper.cpp b/src/details/file_helper.cpp index 671ed05b..8db802b8 100644 --- a/src/details/file_helper.cpp +++ b/src/details/file_helper.cpp @@ -1,9 +1,9 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) +#include #include #include -#include #include #include @@ -14,47 +14,36 @@ namespace spdlog { namespace details { file_helper::file_helper(const file_event_handlers &event_handlers) - : event_handlers_(event_handlers) -{} + : event_handlers_(event_handlers) {} -file_helper::~file_helper() -{ - close(); -} +file_helper::~file_helper() { close(); } -void file_helper::open(const filename_t &fname, bool truncate) -{ +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; @@ -66,73 +55,56 @@ void file_helper::open(const filename_t &fname, bool truncate) throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); } -void file_helper::reopen(bool truncate) -{ - if (filename_.empty()) - { +void file_helper::reopen(bool truncate) { + if (filename_.empty()) { throw_spdlog_ex("Failed re opening file - was not opened before"); } this->open(filename_, truncate); } -void file_helper::flush() -{ - if (std::fflush(fd_) != 0) - { +void file_helper::flush() { + if (std::fflush(fd_) != 0) { throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); } } -void file_helper::sync() -{ - if (!os::fsync(fd_)) - { +void file_helper::sync() { + if (!os::fsync(fd_)) { throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); } } -void file_helper::close() -{ - if (fd_ != nullptr) - { - if (event_handlers_.before_close) - { +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_); } } } -void file_helper::write(const memory_buf_t &buf) -{ +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); } } -size_t file_helper::size() const -{ - if (fd_ == nullptr) - { +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_); } -const filename_t &file_helper::filename() const -{ - return filename_; -} +const filename_t &file_helper::filename() const { return filename_; } // // return file path and its extension: @@ -147,21 +119,18 @@ const filename_t &file_helper::filename() const // ".mylog" => (".mylog". "") // "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") -std::tuple file_helper::split_by_extension(const filename_t &fname) -{ +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/src/details/log_msg.cpp b/src/details/log_msg.cpp index a94752dd..f98ae8dd 100644 --- a/src/details/log_msg.cpp +++ b/src/details/log_msg.cpp @@ -7,25 +7,28 @@ namespace spdlog { namespace details { -log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, - spdlog::string_view_t msg) - : logger_name(a_logger_name) - , log_level(lvl) - , time(log_time) +log_msg::log_msg(spdlog::log_clock::time_point log_time, + spdlog::source_loc loc, + string_view_t a_logger_name, + spdlog::level lvl, + spdlog::string_view_t msg) + : logger_name(a_logger_name), + log_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) { +} log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg) - : log_msg(os::now(), loc, a_logger_name, lvl, msg) -{} + : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg) - : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) -{} + : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} } // namespace details } // namespace spdlog diff --git a/src/details/log_msg_buffer.cpp b/src/details/log_msg_buffer.cpp index f4276ed8..a82d33be 100644 --- a/src/details/log_msg_buffer.cpp +++ b/src/details/log_msg_buffer.cpp @@ -7,30 +7,26 @@ namespace spdlog { namespace details { 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(); } 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(); } log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept - : log_msg{other} - , buffer{std::move(other.buffer)} -{ + : log_msg{other}, + buffer{std::move(other.buffer)} { update_string_views(); } -log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) -{ +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()); @@ -38,16 +34,14 @@ log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) return *this; } -log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept -{ +log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept { log_msg::operator=(other); buffer = std::move(other.buffer); update_string_views(); return *this; } -void log_msg_buffer::update_string_views() -{ +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/src/details/os.cpp b/src/details/os.cpp index 913e8ed3..865ff04a 100644 --- a/src/details/os.cpp +++ b/src/details/os.cpp @@ -1,88 +1,87 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include #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_FILENAMES) -# include -# include -# endif + #if 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::log_clock::time_point now() noexcept -{ +spdlog::log_clock::time_point now() 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 } -std::tm localtime(const std::time_t &time_tt) noexcept -{ +std::tm localtime(const std::time_t &time_tt) noexcept { #ifdef _WIN32 std::tm tm; @@ -94,14 +93,12 @@ std::tm localtime(const std::time_t &time_tt) noexcept return tm; } -std::tm localtime() noexcept -{ +std::tm localtime() noexcept { std::time_t now_t = ::time(nullptr); return localtime(now_t); } -std::tm gmtime(const std::time_t &time_tt) noexcept -{ +std::tm gmtime(const std::time_t &time_tt) noexcept { #ifdef _WIN32 std::tm tm; @@ -113,55 +110,48 @@ std::tm gmtime(const std::time_t &time_tt) noexcept return tm; } -std::tm gmtime() noexcept -{ +std::tm gmtime() noexcept { std::time_t now_t = ::time(nullptr); return gmtime(now_t); } // fopen_s on non windows for writing -bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) -{ +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; } -int remove(const filename_t &filename) noexcept -{ +int remove(const filename_t &filename) noexcept { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wremove(filename.c_str()); #else @@ -169,13 +159,9 @@ int remove(const filename_t &filename) noexcept #endif } -int remove_if_exists(const filename_t &filename) noexcept -{ - return path_exists(filename) ? remove(filename) : 0; -} +int remove_if_exists(const filename_t &filename) noexcept { return path_exists(filename) ? remove(filename) : 0; } -int rename(const filename_t &filename1, const filename_t &filename2) noexcept -{ +int rename(const filename_t &filename1, const filename_t &filename2) noexcept { #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) return ::_wrename(filename1.c_str(), filename2.c_str()); #else @@ -184,14 +170,13 @@ int rename(const filename_t &filename1, const filename_t &filename2) noexcept } // Return true if path exists (file or directory) -bool path_exists(const filename_t &filename) noexcept -{ +bool path_exists(const filename_t &filename) 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; @@ -200,99 +185,89 @@ bool path_exists(const filename_t &filename) 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 -size_t filesize(FILE *f) -{ - if (f == nullptr) - { +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 -int utc_minutes_offset(const std::tm &tm) -{ +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); @@ -317,9 +292,9 @@ 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 @@ -328,14 +303,13 @@ 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) -size_t _thread_id() noexcept -{ +size_t _thread_id() 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; @@ -356,20 +330,17 @@ size_t _thread_id() 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())); @@ -377,8 +348,7 @@ size_t _thread_id() noexcept } // Return current thread id as size_t (from thread local storage) -size_t thread_id() noexcept -{ +size_t thread_id() noexcept { // cache thread id in tls static thread_local const size_t tid = _thread_id(); return tid; @@ -386,8 +356,7 @@ size_t thread_id() noexcept // This is avoid msvc issue in sleep_for that happens if the clock changes. // See https://github.com/gabime/spdlog/issues/609 -void sleep_for_millis(unsigned int milliseconds) noexcept -{ +void sleep_for_millis(unsigned int milliseconds) noexcept { #if defined(_WIN32) ::Sleep(milliseconds); #else @@ -397,21 +366,16 @@ void sleep_for_millis(unsigned int milliseconds) noexcept // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -std::string filename_to_str(const filename_t &filename) -{ +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 -std::string filename_to_str(const filename_t &filename) -{ - return filename; -} +std::string filename_to_str(const filename_t &filename) { return filename; } #endif -int pid() noexcept -{ +int pid() noexcept { #ifdef _WIN32 return static_cast(::GetCurrentProcessId()); @@ -422,29 +386,28 @@ int pid() noexcept // Determine if the terminal supports colors // Based on: https://github.com/agauniyal/rang/ -bool is_color_terminal() noexcept -{ +bool is_color_terminal() 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; @@ -453,8 +416,7 @@ bool is_color_terminal() noexcept // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ -bool in_terminal(FILE *file) noexcept -{ +bool in_terminal(FILE *file) noexcept { #ifdef _WIN32 return ::_isatty(_fileno(file)) != 0; @@ -464,33 +426,27 @@ bool in_terminal(FILE *file) noexcept } #if defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) -void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) -{ - if (wstr.size() > static_cast((std::numeric_limits::max)()) / 2 - 1) - { +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; } @@ -499,16 +455,13 @@ void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); } -void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) -{ - if (str.size() > static_cast((std::numeric_limits::max)()) - 1) - { +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; } @@ -516,12 +469,11 @@ 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; } @@ -532,14 +484,13 @@ void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) #endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) // return true on success -static bool mkdir_(const filename_t &path) -{ +static 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 @@ -547,32 +498,26 @@ static 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 -bool create_dir(const filename_t &path) -{ - if (path_exists(path)) - { +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; @@ -586,24 +531,22 @@ bool create_dir(const filename_t &path) // "abc/" => "abc" // "abc" => "" // "abc///" => "abc//" -filename_t dir_name(const filename_t &path) -{ +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 getenv(const char *field) -{ +std::string 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{}; @@ -612,8 +555,7 @@ std::string getenv(const char *field) // Do fsync by FILE handlerpointer // Return true on success -bool fsync(FILE *fp) -{ +bool fsync(FILE *fp) { #ifdef _WIN32 return FlushFileBuffers(reinterpret_cast(_get_osfhandle(_fileno(fp)))) != 0; #else diff --git a/src/details/periodic_worker.cpp b/src/details/periodic_worker.cpp index 960a540a..0b91541f 100644 --- a/src/details/periodic_worker.cpp +++ b/src/details/periodic_worker.cpp @@ -7,10 +7,8 @@ namespace spdlog { namespace details { // stop the worker thread and join it -periodic_worker::~periodic_worker() -{ - if (worker_thread_.joinable()) - { +periodic_worker::~periodic_worker() { + if (worker_thread_.joinable()) { { std::lock_guard lock(mutex_); active_ = false; diff --git a/src/details/registry.cpp b/src/details/registry.cpp index 42736b50..b9480192 100644 --- a/src/details/registry.cpp +++ b/src/details/registry.cpp @@ -9,12 +9,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 @@ -27,16 +27,15 @@ namespace spdlog { namespace details { 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)); @@ -47,19 +46,16 @@ registry::registry() registry::~registry() = default; -void registry::register_logger(std::shared_ptr new_logger) -{ +void registry::register_logger(std::shared_ptr new_logger) { std::lock_guard lock(logger_map_mutex_); register_logger_(std::move(new_logger)); } -void registry::initialize_logger(std::shared_ptr new_logger) -{ +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_); } @@ -70,21 +66,18 @@ void registry::initialize_logger(std::shared_ptr new_logger) new_logger->flush_on(flush_level_); - if (automatic_registration_) - { + if (automatic_registration_) { register_logger_(std::move(new_logger)); } } -std::shared_ptr registry::get(const std::string &logger_name) -{ +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; } -std::shared_ptr registry::default_logger() -{ +std::shared_ptr registry::default_logger() { std::lock_guard lock(logger_map_mutex_); return default_logger_; } @@ -93,120 +86,96 @@ 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. -logger *registry::get_default_raw() -{ - return default_logger_.get(); -} +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. -void registry::set_default_logger(std::shared_ptr new_default_logger) -{ +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); } -void registry::set_tp(std::shared_ptr tp) -{ +void registry::set_tp(std::shared_ptr tp) { std::lock_guard lock(tp_mutex_); tp_ = std::move(tp); } -std::shared_ptr registry::get_tp() -{ +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 -void registry::set_formatter(std::unique_ptr formatter) -{ +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()); } } -void registry::set_level(level level) -{ +void registry::set_level(level level) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->set_level(level); } global_log_level_ = level; } -void registry::flush_on(level level) -{ +void registry::flush_on(level level) { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->flush_on(level); } flush_level_ = level; } -void registry::set_error_handler(err_handler handler) -{ +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); } -void registry::apply_all(const std::function)> &fun) -{ +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); } } -void registry::flush_all() -{ +void registry::flush_all() { std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) - { + for (auto &l : loggers_) { l.second->flush(); } } -void registry::drop(const std::string &logger_name) -{ +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(); } } -void registry::drop_all() -{ +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 -void registry::shutdown() -{ +void registry::shutdown() { { std::lock_guard lock(flusher_mutex_); periodic_flusher_.reset(); @@ -220,62 +189,48 @@ void registry::shutdown() } } -std::recursive_mutex ®istry::tp_mutex() -{ - return tp_mutex_; -} +std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } -void registry::set_automatic_registration(bool automatic_registration) -{ +void registry::set_automatic_registration(bool automatic_registration) { std::lock_guard lock(logger_map_mutex_); automatic_registration_ = automatic_registration; } -void registry::set_levels(log_levels levels, level *global_level) -{ +void registry::set_levels(log_levels levels, level *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); } } } -registry ®istry::instance() -{ +registry ®istry::instance() { static registry s_instance; return s_instance; } -void registry::apply_logger_env_levels(std::shared_ptr new_logger) -{ +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); } -void registry::throw_if_exists_(const std::string &logger_name) -{ - if (loggers_.find(logger_name) != loggers_.end()) - { +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"); } } -void registry::register_logger_(std::shared_ptr new_logger) -{ +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/src/details/thread_pool.cpp b/src/details/thread_pool.cpp index 26f3f5aa..4b2ebeec 100644 --- a/src/details/thread_pool.cpp +++ b/src/details/thread_pool.cpp @@ -1,23 +1,23 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include -#include #include +#include +#include namespace spdlog { namespace details { -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) - { +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_(); @@ -27,100 +27,71 @@ 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, [] {}) {} 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 -thread_pool::~thread_pool() -{ - SPDLOG_TRY - { - for (size_t i = 0; i < threads_.size(); i++) - { +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 thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) -{ +void 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 thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) -{ +void 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 thread_pool::overrun_counter() -{ - return q_.overrun_counter(); -} +size_t thread_pool::overrun_counter() { return q_.overrun_counter(); } -void thread_pool::reset_overrun_counter() -{ - q_.reset_overrun_counter(); -} +void thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } -size_t thread_pool::discard_counter() -{ - return q_.discard_counter(); -} +size_t thread_pool::discard_counter() { return q_.discard_counter(); } -void thread_pool::reset_discard_counter() -{ - q_.reset_discard_counter(); -} +void thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } -size_t thread_pool::queue_size() -{ - return q_.size(); -} +size_t thread_pool::queue_size() { return q_.size(); } -void thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) -{ - if (overflow_policy == async_overflow_policy::block) - { +void 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 thread_pool::worker_loop_() -{ - while (process_next_msg_()) {} +void 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 thread_pool::process_next_msg_() -{ +bool 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/src/fmt/bundled_fmtlib_format.cpp b/src/fmt/bundled_fmtlib_format.cpp index f8fb6b3f..83923746 100644 --- a/src/fmt/bundled_fmtlib_format.cpp +++ b/src/fmt/bundled_fmtlib_format.cpp @@ -4,17 +4,17 @@ #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; -# ifndef FMT_STATIC_THOUSANDS_SEPARATOR + #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. diff --git a/src/logger.cpp b/src/logger.cpp index d075826f..5a4fe314 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -2,8 +2,8 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #include -#include #include +#include #include #include @@ -12,128 +12,82 @@ namespace spdlog { // public methods logger::logger(const logger &other) noexcept - : 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_) -{} + : 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_) {} logger::logger(logger &&other) 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_)) -{} + : 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_)) {} -void logger::set_level(level level) -{ - level_.store(level); -} +void logger::set_level(level level) { level_.store(level); } -level logger::log_level() const -{ - return static_cast(level_.load(std::memory_order_relaxed)); -} +level logger::log_level() const { return static_cast(level_.load(std::memory_order_relaxed)); } -const std::string &logger::name() const -{ - return name_; -} +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. -void logger::set_formatter(std::unique_ptr f) -{ - for (auto it = sinks_.begin(); it != sinks_.end(); ++it) - { - if (std::next(it) == sinks_.end()) - { +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()); } } } -void logger::set_pattern(std::string pattern, pattern_time_type time_type) -{ +void logger::set_pattern(std::string pattern, pattern_time_type time_type) { auto new_formatter = std::make_unique(std::move(pattern), time_type); set_formatter(std::move(new_formatter)); } // flush functions -void logger::flush() -{ - flush_(); -} +void logger::flush() { flush_(); } -void logger::flush_on(level level) -{ - flush_level_.store(level); -} +void logger::flush_on(level level) { flush_level_.store(level); } -level logger::flush_level() const -{ - return static_cast(flush_level_.load(std::memory_order_relaxed)); -} +level logger::flush_level() const { return static_cast(flush_level_.load(std::memory_order_relaxed)); } // sinks -const std::vector &logger::sinks() const -{ - return sinks_; -} +const std::vector &logger::sinks() const { return sinks_; } -std::vector &logger::sinks() -{ - return sinks_; -} +std::vector &logger::sinks() { return sinks_; } // error handler -void logger::set_error_handler(err_handler handler) -{ - custom_err_handler_ = std::move(handler); -} +void logger::set_error_handler(err_handler handler) { custom_err_handler_ = std::move(handler); } // create new logger with same sinks and configuration. -std::shared_ptr logger::clone(std::string logger_name) -{ +std::shared_ptr logger::clone(std::string logger_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(logger_name); return cloned; } -void logger::flush_() -{ - for (auto &sink : sinks_) - { - SPDLOG_TRY - { - sink->flush(); - } +void logger::flush_() { + for (auto &sink : sinks_) { + SPDLOG_TRY { sink->flush(); } SPDLOG_LOGGER_CATCH(source_loc()) } } -bool logger::should_flush_(const details::log_msg &msg) -{ +bool logger::should_flush_(const details::log_msg &msg) { auto flush_level = flush_level_.load(std::memory_order_relaxed); return (msg.log_level >= flush_level) && (msg.log_level != level::off); } -void logger::err_handler_(const std::string &msg) -{ - if (custom_err_handler_) - { +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; @@ -141,8 +95,7 @@ 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; @@ -152,7 +105,8 @@ 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/src/pattern_formatter.cpp b/src/pattern_formatter.cpp index 9dbcc36f..6e8a7f7e 100644 --- a/src/pattern_formatter.cpp +++ b/src/pattern_formatter.cpp @@ -1,19 +1,19 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include #include #include #include #include #include +#include #include #include -#include -#include #include +#include #include +#include #include #include #include @@ -24,26 +24,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); @@ -51,28 +45,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_); } @@ -82,43 +70,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 = to_string_view(msg.log_level); ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); @@ -126,16 +106,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{to_short_c_str(msg.log_level)}; ScopedPadder p(level_name.size(), padinfo_, dest); fmt_helper::append_string_view(level_name, dest); @@ -146,29 +123,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); @@ -176,18 +144,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); @@ -195,18 +161,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); @@ -214,19 +178,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); @@ -234,16 +195,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); @@ -266,16 +224,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); @@ -283,16 +238,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); @@ -305,16 +257,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); @@ -322,16 +271,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); @@ -339,16 +285,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); @@ -356,16 +299,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); @@ -373,16 +313,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); @@ -390,16 +327,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); @@ -407,16 +341,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); @@ -424,16 +355,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); @@ -442,16 +370,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; @@ -461,16 +386,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); @@ -479,16 +401,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(); @@ -498,16 +417,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); @@ -515,16 +431,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); @@ -539,16 +452,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); @@ -559,16 +469,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); @@ -581,32 +488,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('+'); } @@ -619,11 +520,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; } @@ -632,16 +531,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); @@ -649,16 +545,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); @@ -666,49 +559,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); } @@ -717,57 +597,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; } @@ -779,18 +647,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; } @@ -800,29 +664,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); @@ -831,13 +689,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; } @@ -848,18 +704,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; } @@ -871,18 +723,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; } @@ -893,19 +741,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; @@ -921,15 +766,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; @@ -938,8 +780,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_); @@ -970,8 +811,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(']'); @@ -988,10 +828,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); @@ -1009,38 +849,38 @@ private: } // namespace details -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)) -{ +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 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(std::make_unique(details::padding_info{})); } -std::unique_ptr pattern_formatter::clone() const -{ +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 = std::make_unique(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters)); + auto cloned = + std::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); @@ -1049,54 +889,42 @@ std::unique_ptr pattern_formatter::clone() const #endif } -void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) -{ - if (need_localtime_) - { +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); } -void pattern_formatter::set_pattern(std::string pattern) -{ +void pattern_formatter::set_pattern(std::string pattern) { pattern_ = std::move(pattern); need_localtime_ = false; compile_pattern_(pattern_); } -void pattern_formatter::need_localtime(bool need) -{ - need_localtime_ = need; -} +void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } -std::tm pattern_formatter::get_time_(const details::log_msg &msg) -{ - if (pattern_time_type_ == pattern_time_type::local) - { +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 -void pattern_formatter::handle_flag_(char flag, details::padding_info padding) -{ +template +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)); @@ -1104,8 +932,7 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) } // process built-in flags - switch (flag) - { + switch (flag) { case ('+'): // default formatter formatters_.push_back(std::make_unique(padding)); need_localtime_ = true; @@ -1300,8 +1127,7 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) default: // Unknown flag appears as is auto unknown_flag = std::make_unique(); - if (!padding.truncate_) - { + if (!padding.truncate_) { unknown_flag->add_ch('%'); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); @@ -1309,8 +1135,7 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) // 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(std::make_unique>(padding)); unknown_flag->add_ch(flag); @@ -1324,19 +1149,17 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) // 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. -details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end) -{ +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; @@ -1350,41 +1173,33 @@ details::padding_info pattern_formatter::handle_padspec_(std::string::const_iter 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}; } -void pattern_formatter::compile_pattern_(const std::string &pattern) -{ +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)); @@ -1392,26 +1207,18 @@ void pattern_formatter::compile_pattern_(const std::string &pattern) 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 = std::make_unique(); } user_chars->add_ch(*it); diff --git a/src/sinks/ansicolor_sink.cpp b/src/sinks/ansicolor_sink.cpp index 0c00e650..dae34c7d 100644 --- a/src/sinks/ansicolor_sink.cpp +++ b/src/sinks/ansicolor_sink.cpp @@ -3,17 +3,17 @@ #include -#include #include +#include namespace spdlog { namespace sinks { -template +template ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) - : target_file_(target_file) - , mutex_(ConsoleMutex::mutex()) - , formatter_(std::make_unique()) + : target_file_(target_file), + mutex_(ConsoleMutex::mutex()), + formatter_(std::make_unique()) { set_color_mode(mode); @@ -26,16 +26,14 @@ ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) colors_.at(level_to_number(level::off)) = to_string_(reset); } -template -void ansicolor_sink::set_color(level color_level, string_view_t color) -{ +template +void ansicolor_sink::set_color(level color_level, string_view_t color) { std::lock_guard lock(mutex_); colors_.at(level_to_number(color_level)) = to_string_(color); } -template -void ansicolor_sink::log(const details::log_msg &msg) -{ +template +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_); @@ -43,8 +41,7 @@ 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 @@ -53,46 +50,39 @@ 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 -void ansicolor_sink::flush() -{ +template +void ansicolor_sink::flush() { std::lock_guard lock(mutex_); fflush(target_file_); } -template -void ansicolor_sink::set_pattern(const std::string &pattern) -{ +template +void ansicolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) -{ +template +void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } -template -bool ansicolor_sink::should_color() -{ +template +bool ansicolor_sink::should_color() { return should_do_colors_; } -template -void ansicolor_sink::set_color_mode(color_mode mode) -{ - switch (mode) - { +template +void ansicolor_sink::set_color_mode(color_mode mode) { + switch (mode) { case color_mode::always: should_do_colors_ = true; return; @@ -107,35 +97,30 @@ void ansicolor_sink::set_color_mode(color_mode mode) } } -template -void ansicolor_sink::print_ccode_(const string_view_t &color_code) -{ +template +void ansicolor_sink::print_ccode_(const string_view_t &color_code) { fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); } -template -void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) -{ +template +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 -std::string ansicolor_sink::to_string_(const string_view_t &sv) -{ +template +std::string ansicolor_sink::to_string_(const string_view_t &sv) { return {sv.data(), sv.size()}; } // ansicolor_stdout_sink -template +template ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) - : ansicolor_sink(stdout, mode) -{} + : ansicolor_sink(stdout, mode) {} // ansicolor_stderr_sink -template +template ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) - : ansicolor_sink(stderr, mode) -{} + : ansicolor_sink(stderr, mode) {} } // namespace sinks } // namespace spdlog diff --git a/src/sinks/base_sink.cpp b/src/sinks/base_sink.cpp index 92dba2ba..5e81d0f3 100644 --- a/src/sinks/base_sink.cpp +++ b/src/sinks/base_sink.cpp @@ -1,60 +1,52 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include #include #include +#include #include #include -template +template spdlog::sinks::base_sink::base_sink() - : formatter_{std::make_unique()} -{} + : formatter_{std::make_unique()} {} -template +template spdlog::sinks::base_sink::base_sink(std::unique_ptr formatter) - : formatter_{std::move(formatter)} -{} + : formatter_{std::move(formatter)} {} -template -void spdlog::sinks::base_sink::log(const details::log_msg &msg) -{ +template +void spdlog::sinks::base_sink::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); sink_it_(msg); } -template -void spdlog::sinks::base_sink::flush() -{ +template +void spdlog::sinks::base_sink::flush() { std::lock_guard lock(mutex_); flush_(); } -template -void spdlog::sinks::base_sink::set_pattern(const std::string &pattern) -{ +template +void spdlog::sinks::base_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); set_pattern_(pattern); } -template -void spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) -{ +template +void spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); set_formatter_(std::move(sink_formatter)); } -template -void spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) -{ +template +void spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) { set_formatter_(std::make_unique(pattern)); } -template -void spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) -{ +template +void spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) { formatter_ = std::move(sink_formatter); } diff --git a/src/sinks/basic_file_sink.cpp b/src/sinks/basic_file_sink.cpp index 2510d416..40c627b7 100644 --- a/src/sinks/basic_file_sink.cpp +++ b/src/sinks/basic_file_sink.cpp @@ -9,30 +9,28 @@ namespace spdlog { namespace sinks { -template -basic_file_sink::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers) - : file_helper_{event_handlers} -{ +template +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 -const filename_t &basic_file_sink::filename() const -{ +template +const filename_t &basic_file_sink::filename() const { return file_helper_.filename(); } -template -void basic_file_sink::sink_it_(const details::log_msg &msg) -{ +template +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 -void basic_file_sink::flush_() -{ +template +void basic_file_sink::flush_() { file_helper_.flush(); } diff --git a/src/sinks/rotating_file_sink.cpp b/src/sinks/rotating_file_sink.cpp index 7cd984ef..3d2e74db 100644 --- a/src/sinks/rotating_file_sink.cpp +++ b/src/sinks/rotating_file_sink.cpp @@ -16,27 +16,26 @@ namespace spdlog { namespace sinks { -template -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 +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; } @@ -44,11 +43,9 @@ 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 -filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) -{ - if (index == 0u) - { +template +filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) { + if (index == 0u) { return filename; } @@ -57,16 +54,14 @@ filename_t rotating_file_sink::calc_filename(const filename_t &filename, return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext); } -template -filename_t rotating_file_sink::filename() -{ +template +filename_t rotating_file_sink::filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } -template -void rotating_file_sink::sink_it_(const details::log_msg &msg) -{ +template +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(); @@ -74,11 +69,9 @@ void rotating_file_sink::sink_it_(const details::log_msg &msg) // 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(); } @@ -87,9 +80,8 @@ void rotating_file_sink::sink_it_(const details::log_msg &msg) current_size_ = new_size; } -template -void rotating_file_sink::flush_() -{ +template +void rotating_file_sink::flush_() { file_helper_.flush(); } @@ -98,33 +90,30 @@ void rotating_file_sink::flush_() // log.1.txt -> log.2.txt // log.2.txt -> log.3.txt // log.3.txt -> delete -template -void rotating_file_sink::rotate_() -{ +template +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); } } } @@ -133,9 +122,8 @@ void rotating_file_sink::rotate_() // delete the target if exists, and rename the src file to target // return true on success, false otherwise. -template -bool rotating_file_sink::rename_file_(const filename_t &src_filename, const filename_t &target_filename) -{ +template +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/src/sinks/sink.cpp b/src/sinks/sink.cpp index 0b15f535..a19c21d4 100644 --- a/src/sinks/sink.cpp +++ b/src/sinks/sink.cpp @@ -5,17 +5,12 @@ #include -bool spdlog::sinks::sink::should_log(spdlog::level msg_level) const -{ +bool spdlog::sinks::sink::should_log(spdlog::level msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } -void spdlog::sinks::sink::set_level(level level) -{ - level_.store(level, std::memory_order_relaxed); -} +void spdlog::sinks::sink::set_level(level level) { level_.store(level, std::memory_order_relaxed); } -spdlog::level spdlog::sinks::sink::log_level() const -{ +spdlog::level spdlog::sinks::sink::log_level() const { return static_cast(level_.load(std::memory_order_relaxed)); } diff --git a/src/sinks/stdout_color_sinks.cpp b/src/sinks/stdout_color_sinks.cpp index 2b477c7c..cda9c70e 100644 --- a/src/sinks/stdout_color_sinks.cpp +++ b/src/sinks/stdout_color_sinks.cpp @@ -1,60 +1,56 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include -#include #include -#include #include +#include +#include +#include namespace spdlog { -template -std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) -{ +template +std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) -{ +template +std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) -{ +template +std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } -template -std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) -{ +template +std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } } // namespace spdlog // template instantiations -template SPDLOG_API std::shared_ptr spdlog::stdout_color_mt( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stdout_color_mt(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stdout_color_st( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stdout_color_st(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_mt( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stderr_color_mt(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_st( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stderr_color_st(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stdout_color_mt( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stdout_color_mt(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stdout_color_st( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stdout_color_st(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_mt( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stderr_color_mt(const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_st( - const std::string &logger_name, color_mode mode); +template SPDLOG_API std::shared_ptr +spdlog::stderr_color_st(const std::string &logger_name, color_mode mode); diff --git a/src/sinks/stdout_sinks.cpp b/src/sinks/stdout_sinks.cpp index 02ee1803..a47f608c 100644 --- a/src/sinks/stdout_sinks.cpp +++ b/src/sinks/stdout_sinks.cpp @@ -1,33 +1,32 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include -#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 stdout_sink_base::stdout_sink_base(FILE *file) - : mutex_(ConsoleMutex::mutex()) - , file_(file) - , formatter_(std::make_unique()) -{ + : mutex_(ConsoleMutex::mutex()), + file_(file), + formatter_(std::make_unique()) { #ifdef _WIN32 // get windows handle from the FILE* object @@ -36,19 +35,16 @@ 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 -void stdout_sink_base::log(const details::log_msg &msg) -{ +template +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_); @@ -57,8 +53,7 @@ void stdout_sink_base::log(const details::log_msg &msg) 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 @@ -70,63 +65,54 @@ void stdout_sink_base::log(const details::log_msg &msg) ::fflush(file_); // flush every line to terminal } -template -void stdout_sink_base::flush() -{ +template +void stdout_sink_base::flush() { std::lock_guard lock(mutex_); fflush(file_); } -template -void stdout_sink_base::set_pattern(const std::string &pattern) -{ +template +void stdout_sink_base::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) -{ +template +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 stdout_sink::stdout_sink() - : stdout_sink_base(stdout) -{} + : stdout_sink_base(stdout) {} // stderr sink -template +template stderr_sink::stderr_sink() - : stdout_sink_base(stderr) -{} + : stdout_sink_base(stderr) {} } // namespace sinks // factory methods -template -std::shared_ptr stdout_logger_mt(const std::string &logger_name) -{ +template +std::shared_ptr stdout_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } -template -std::shared_ptr stdout_logger_st(const std::string &logger_name) -{ +template +std::shared_ptr stdout_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } -template -std::shared_ptr stderr_logger_mt(const std::string &logger_name) -{ +template +std::shared_ptr stderr_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } -template -std::shared_ptr stderr_logger_st(const std::string &logger_name) -{ +template +std::shared_ptr stderr_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } } // namespace spdlog @@ -141,15 +127,23 @@ template class SPDLOG_API spdlog::sinks::stderr_sink; // template instantiations for stdout/stderr factory functions -#include #include +#include -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); diff --git a/src/sinks/wincolor_sink.cpp b/src/sinks/wincolor_sink.cpp index 7601ebef..54678408 100644 --- a/src/sinks/wincolor_sink.cpp +++ b/src/sinks/wincolor_sink.cpp @@ -2,52 +2,49 @@ // Distributed under the MIT License (http://opensource.org/licenses/MIT) #ifdef _WIN32 -#include -#include -#include -#include + #include + #include + #include + #include -#include + #include namespace spdlog { namespace sinks { -template +template wincolor_sink::wincolor_sink(void *out_handle, color_mode mode) - : out_handle_(out_handle) - , mutex_(ConsoleMutex::mutex()) - , formatter_(std::make_unique()) -{ + : out_handle_(out_handle), + mutex_(ConsoleMutex::mutex()), + formatter_(std::make_unique()) { set_color_mode_impl(mode); // set level colors - colors_.at(level_to_number(level::trace)) = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white - colors_.at(level_to_number(level::debug)) = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan - colors_.at(level_to_number(level::info)) = FOREGROUND_GREEN; // green - colors_.at(level_to_number(level::warn)) = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow - colors_.at(level_to_number(level::err)) = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red - colors_.at(level_to_number(level::critical)) = - BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY; // intense white on red background + colors_.at(level_to_number(level::trace)) = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white + colors_.at(level_to_number(level::debug)) = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan + colors_.at(level_to_number(level::info)) = FOREGROUND_GREEN; // green + colors_.at(level_to_number(level::warn)) = + FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow + colors_.at(level_to_number(level::err)) = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red + colors_.at(level_to_number(level::critical)) = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | + FOREGROUND_BLUE | + FOREGROUND_INTENSITY; // intense white on red background colors_.at(level_to_number(level::off)) = 0; } -template -wincolor_sink::~wincolor_sink() -{ +template +wincolor_sink::~wincolor_sink() { this->flush(); } // change the color for the given level -template -void wincolor_sink::set_color(level level, std::uint16_t color) -{ +template +void wincolor_sink::set_color(level level, std::uint16_t color) { std::lock_guard lock(mutex_); colors_[level_to_number(level)] = color; } -template -void wincolor_sink::log(const details::log_msg &msg) -{ - if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) - { +template +void wincolor_sink::log(const details::log_msg &msg) { + if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) { return; } @@ -56,8 +53,7 @@ void 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 @@ -66,63 +62,52 @@ void wincolor_sink::log(const details::log_msg &msg) // reset to orig colors ::SetConsoleTextAttribute(static_cast(out_handle_), orig_attribs); print_range_(formatted, msg.color_range_end, formatted.size()); - } - else // print without colors if color range is invalid (or color is disabled) + } else // print without colors if color range is invalid (or color is disabled) { write_to_file_(formatted); } } -template -void wincolor_sink::flush() -{ +template +void wincolor_sink::flush() { // windows console always flushed? } -template -void wincolor_sink::set_pattern(const std::string &pattern) -{ +template +void wincolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } -template -void wincolor_sink::set_formatter(std::unique_ptr sink_formatter) -{ +template +void wincolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } -template -void wincolor_sink::set_color_mode(color_mode mode) -{ +template +void wincolor_sink::set_color_mode(color_mode mode) { std::lock_guard lock(mutex_); set_color_mode_impl(mode); } -template -void wincolor_sink::set_color_mode_impl(color_mode mode) -{ - if (mode == color_mode::automatic) - { +template +void 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 wincolor_sink::set_foreground_color_(std::uint16_t attribs) -{ +template +std::uint16_t 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; } @@ -135,20 +120,18 @@ std::uint16_t wincolor_sink::set_foreground_color_(std::uint16_t a } // print a range of formatted message to console -template -void wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) -{ - if (end > start) - { +template +void 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 wincolor_sink::write_to_file_(const memory_buf_t &formatted) -{ +template +void 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); @@ -156,16 +139,14 @@ void wincolor_sink::write_to_file_(const memory_buf_t &formatted) } // wincolor_stdout_sink -template +template 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 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/src/spdlog.cpp b/src/spdlog.cpp index 881c8dee..291d6599 100644 --- a/src/spdlog.cpp +++ b/src/spdlog.cpp @@ -1,104 +1,65 @@ // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // Distributed under the MIT License (http://opensource.org/licenses/MIT) -#include #include #include +#include namespace spdlog { -void initialize_logger(std::shared_ptr logger) -{ +void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } -std::shared_ptr get(const std::string &name) -{ - return details::registry::instance().get(name); -} +std::shared_ptr get(const std::string &name) { return details::registry::instance().get(name); } -void set_formatter(std::unique_ptr formatter) -{ +void set_formatter(std::unique_ptr formatter) { details::registry::instance().set_formatter(std::move(formatter)); } -void set_pattern(std::string pattern, pattern_time_type time_type) -{ +void set_pattern(std::string pattern, pattern_time_type time_type) { set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } -level get_level() -{ - return default_logger_raw()->log_level(); -} +level get_level() { return default_logger_raw()->log_level(); } -bool should_log(level level) -{ - return default_logger_raw()->should_log(level); -} +bool should_log(level level) { return default_logger_raw()->should_log(level); } -void set_level(level level) -{ - details::registry::instance().set_level(level); -} +void set_level(level level) { details::registry::instance().set_level(level); } -void flush_on(level level) -{ - details::registry::instance().flush_on(level); -} +void flush_on(level level) { details::registry::instance().flush_on(level); } -void set_error_handler(void (*handler)(const std::string &msg)) -{ +void set_error_handler(void (*handler)(const std::string &msg)) { details::registry::instance().set_error_handler(handler); } -void register_logger(std::shared_ptr logger) -{ +void register_logger(std::shared_ptr logger) { details::registry::instance().register_logger(std::move(logger)); } -void apply_all(const std::function)> &fun) -{ +void apply_all(const std::function)> &fun) { details::registry::instance().apply_all(fun); } -void drop(const std::string &name) -{ - details::registry::instance().drop(name); -} +void drop(const std::string &name) { details::registry::instance().drop(name); } -void drop_all() -{ - details::registry::instance().drop_all(); -} +void drop_all() { details::registry::instance().drop_all(); } -void shutdown() -{ - details::registry::instance().shutdown(); -} +void shutdown() { details::registry::instance().shutdown(); } -void set_automatic_registration(bool automatic_registration) -{ +void set_automatic_registration(bool automatic_registration) { details::registry::instance().set_automatic_registration(automatic_registration); } -std::shared_ptr default_logger() -{ - return details::registry::instance().default_logger(); -} +std::shared_ptr default_logger() { return details::registry::instance().default_logger(); } -spdlog::logger *default_logger_raw() -{ - return details::registry::instance().get_default_raw(); -} +spdlog::logger *default_logger_raw() { return details::registry::instance().get_default_raw(); } -void set_default_logger(std::shared_ptr default_logger) -{ +void set_default_logger(std::shared_ptr default_logger) { details::registry::instance().set_default_logger(std::move(default_logger)); } -void apply_logger_env_levels(std::shared_ptr logger) -{ +void apply_logger_env_levels(std::shared_ptr logger) { details::registry::instance().apply_logger_env_levels(std::move(logger)); }