From 78c833a09f5ae57abb1f240bdea42015068bb565 Mon Sep 17 00:00:00 2001 From: gabime Date: Tue, 18 Jun 2019 17:05:27 +0300 Subject: [PATCH] clang-format --- include/spdlog/common.h | 2 - include/spdlog/details/console_globals.h | 1 - include/spdlog/logger-inl.h | 406 +++++++++++------------ include/spdlog/logger.h | 3 +- include/spdlog/sinks/ansicolor_sink.h | 6 +- include/spdlog/sinks/wincolor_sink-inl.h | 2 - include/spdlog/sinks/wincolor_sink.h | 4 +- tests/test_pattern_formatter.cpp | 7 +- 8 files changed, 208 insertions(+), 223 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index c18e5c66..ae9f0fa4 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -26,13 +26,11 @@ #include #endif //_WIN32 - #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #include #include #endif - #ifdef SPDLOG_COMPILED_LIB #undef SPDLOG_HEADER_ONLY #define SPDLOG_INLINE diff --git a/include/spdlog/details/console_globals.h b/include/spdlog/details/console_globals.h index dcc82a62..6761a30d 100644 --- a/include/spdlog/details/console_globals.h +++ b/include/spdlog/details/console_globals.h @@ -6,7 +6,6 @@ #include "spdlog/details/null_mutex.h" #include - namespace spdlog { namespace details { diff --git a/include/spdlog/logger-inl.h b/include/spdlog/logger-inl.h index 7df8a1cc..a9c1c989 100644 --- a/include/spdlog/logger-inl.h +++ b/include/spdlog/logger-inl.h @@ -12,227 +12,223 @@ namespace spdlog { - // public methods - SPDLOG_INLINE logger::logger(const logger &other): - name_(other.name_), - sinks_(other.sinks_), - level_(other.level_.load(std::memory_order_relaxed)), - flush_level_(other.flush_level_.load(std::memory_order_relaxed)), - custom_err_handler_(other.custom_err_handler_) +// public methods +SPDLOG_INLINE logger::logger(const logger &other) + : name_(other.name_) + , sinks_(other.sinks_) + , level_(other.level_.load(std::memory_order_relaxed)) + , flush_level_(other.flush_level_.load(std::memory_order_relaxed)) + , custom_err_handler_(other.custom_err_handler_) +{} + +SPDLOG_INLINE logger::logger(logger &&other) + : 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_)) +{} + +SPDLOG_INLINE logger &logger::operator=(logger other) +{ + this->swap(other); + return *this; +} + +SPDLOG_INLINE void logger::swap(spdlog::logger &other) +{ + name_.swap(other.name_); + sinks_.swap(other.sinks_); + + // swap level_ + auto tmp = other.level_.load(); + tmp = level_.exchange(tmp); + other.level_.store(tmp); + + // swap flush level_ + tmp = other.flush_level_.load(); + tmp = flush_level_.exchange(tmp); + other.flush_level_.store(tmp); + + custom_err_handler_.swap(other.custom_err_handler_); +} + +SPDLOG_INLINE void swap(logger &a, logger &b) +{ + a.swap(b); +} + +void logger::log(source_loc loc, level::level_enum lvl, const char *msg) +{ + if (!should_log(lvl)) { + return; } - SPDLOG_INLINE logger::logger(logger &&other): - 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_)) + try { + details::log_msg log_msg(loc, string_view_t(name_), lvl, string_view_t(msg)); + sink_it_(log_msg); } - - - SPDLOG_INLINE logger &logger::operator=(logger other) + catch (const std::exception &ex) { - this->swap(other); - return *this; + err_handler_(ex.what()); } - - SPDLOG_INLINE void logger::swap(spdlog::logger &other) + catch (...) { - name_.swap(other.name_); - sinks_.swap(other.sinks_); - - //swap level_ - auto tmp = other.level_.load(); - tmp = level_.exchange(tmp); - other.level_.store(tmp); - - //swap flush level_ - tmp = other.flush_level_.load(); - tmp = flush_level_.exchange(tmp); - other.flush_level_.store(tmp); - - custom_err_handler_.swap(other.custom_err_handler_); + err_handler_("Unknown exception in logger"); } +} +SPDLOG_INLINE void logger::log(level::level_enum lvl, const char *msg) +{ + log(source_loc{}, lvl, msg); +} - SPDLOG_INLINE void swap(logger &a, logger &b) +SPDLOG_INLINE bool logger::should_log(level::level_enum msg_level) const +{ + return msg_level >= level_.load(std::memory_order_relaxed); +} + +SPDLOG_INLINE void logger::set_level(level::level_enum log_level) +{ + level_.store(log_level); +} + +SPDLOG_INLINE level::level_enum logger::default_level() +{ + return static_cast(SPDLOG_ACTIVE_LEVEL); +} + +SPDLOG_INLINE level::level_enum logger::level() const +{ + return static_cast(level_.load(std::memory_order_relaxed)); +} + +SPDLOG_INLINE const std::string &logger::name() const +{ + return name_; +} + +// set formatting for the sinks in this logger. +// each sink will get a seperate instance of the formatter object. +SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) +{ + for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { - a.swap(b); - } - - void logger::log(source_loc loc, level::level_enum lvl, const char *msg) - { - if (!should_log(lvl)) + if (std::next(it) == sinks_.end()) { - return; - } - - try - { - details::log_msg log_msg(loc, string_view_t(name_), lvl, string_view_t(msg)); - sink_it_(log_msg); - } - catch (const std::exception &ex) - { - err_handler_(ex.what()); - } - catch (...) - { - err_handler_("Unknown exception in logger"); - } - } - - SPDLOG_INLINE void logger::log(level::level_enum lvl, const char *msg) - { - log(source_loc{}, lvl, msg); - } - - SPDLOG_INLINE bool logger::should_log(level::level_enum msg_level) const - { - return msg_level >= level_.load(std::memory_order_relaxed); - } - - SPDLOG_INLINE void logger::set_level(level::level_enum log_level) - { - level_.store(log_level); - } - - SPDLOG_INLINE level::level_enum logger::default_level() - { - return static_cast(SPDLOG_ACTIVE_LEVEL); - } - - SPDLOG_INLINE level::level_enum logger::level() const - { - return static_cast(level_.load(std::memory_order_relaxed)); - } - - SPDLOG_INLINE const std::string &logger::name() const - { - return name_; - } - - // set formatting for the sinks in this logger. - // each sink will get a seperate instance of the formatter object. - SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) - { - for (auto it = sinks_.begin(); it != sinks_.end(); ++it) - { - if (std::next(it) == sinks_.end()) - { - // last element - we can be move it. - (*it)->set_formatter(std::move(f)); - } - else - { - (*it)->set_formatter(f->clone()); - } - } - } - - SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) - { - auto new_formatter = details::make_unique(std::move(pattern), time_type); - set_formatter(std::move(new_formatter)); - } - - // flush functions - SPDLOG_INLINE void logger::flush() - { - try - { - flush_(); - } - catch (const std::exception &ex) - { - err_handler_(ex.what()); - } - catch (...) - { - err_handler_("Unknown exception in logger"); - } - } - - SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) - { - flush_level_.store(log_level); - } - - SPDLOG_INLINE level::level_enum logger::flush_level() const - { - return static_cast(flush_level_.load(std::memory_order_relaxed)); - } - -// sinks - SPDLOG_INLINE const std::vector &logger::sinks() const - { - return sinks_; - } - - SPDLOG_INLINE std::vector &logger::sinks() - { - return sinks_; - } - - // error handler - SPDLOG_INLINE void logger::set_error_handler(err_handler handler) - { - custom_err_handler_ = handler; - } - - // create new logger with same sinks and configuration. - SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) - { - auto cloned = std::make_shared(*this); - cloned->name_ = std::move(logger_name); - return cloned; - } - - // protected methods - SPDLOG_INLINE void logger::sink_it_(details::log_msg &msg) - { - for (auto &sink : sinks_) - { - if (sink->should_log(msg.level)) - { - sink->log(msg); - } - } - - if (should_flush_(msg)) - { - flush_(); - } - } - - SPDLOG_INLINE void logger::flush_() - { - for (auto &sink : sinks_) - { - sink->flush(); - } - } - - SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) - { - auto flush_level = flush_level_.load(std::memory_order_relaxed); - return (msg.level >= flush_level) && (msg.level != level::off); - } - - SPDLOG_INLINE void logger::err_handler_(const std::string &msg) - { - if (custom_err_handler_) - { - custom_err_handler_(msg); + // last element - we can be move it. + (*it)->set_formatter(std::move(f)); } else { - auto tm_time = details::os::localtime(); - char date_buf[64]; - std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); - fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg); + (*it)->set_formatter(f->clone()); } } +} + +SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) +{ + auto new_formatter = details::make_unique(std::move(pattern), time_type); + set_formatter(std::move(new_formatter)); +} + +// flush functions +SPDLOG_INLINE void logger::flush() +{ + try + { + flush_(); + } + catch (const std::exception &ex) + { + err_handler_(ex.what()); + } + catch (...) + { + err_handler_("Unknown exception in logger"); + } +} + +SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) +{ + flush_level_.store(log_level); +} + +SPDLOG_INLINE level::level_enum logger::flush_level() const +{ + return static_cast(flush_level_.load(std::memory_order_relaxed)); +} + +// sinks +SPDLOG_INLINE const std::vector &logger::sinks() const +{ + return sinks_; +} + +SPDLOG_INLINE std::vector &logger::sinks() +{ + return sinks_; +} + +// error handler +SPDLOG_INLINE void logger::set_error_handler(err_handler handler) +{ + custom_err_handler_ = handler; +} + +// create new logger with same sinks and configuration. +SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) +{ + auto cloned = std::make_shared(*this); + cloned->name_ = std::move(logger_name); + return cloned; +} + +// protected methods +SPDLOG_INLINE void logger::sink_it_(details::log_msg &msg) +{ + for (auto &sink : sinks_) + { + if (sink->should_log(msg.level)) + { + sink->log(msg); + } + } + + if (should_flush_(msg)) + { + flush_(); + } +} + +SPDLOG_INLINE void logger::flush_() +{ + for (auto &sink : sinks_) + { + sink->flush(); + } +} + +SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) +{ + auto flush_level = flush_level_.load(std::memory_order_relaxed); + return (msg.level >= flush_level) && (msg.level != level::off); +} + +SPDLOG_INLINE void logger::err_handler_(const std::string &msg) +{ + if (custom_err_handler_) + { + custom_err_handler_(msg); + } + else + { + auto tm_time = details::os::localtime(); + char date_buf[64]; + std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); + fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg); + } +} } // namespace spdlog \ No newline at end of file diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index b11b7820..b0e5d2f9 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -346,11 +346,10 @@ protected: void err_handler_(const std::string &msg); }; -void swap(logger& a, logger& b); +void swap(logger &a, logger &b); } // namespace spdlog - #ifdef SPDLOG_HEADER_ONLY #include "logger-inl.h" #endif diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index 283df48e..09356e7a 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/include/spdlog/sinks/ansicolor_sink.h @@ -25,7 +25,7 @@ class ansicolor_sink : public sink { public: using mutex_t = typename ConsoleMutex::mutex_t; - ansicolor_sink(FILE* target_file, color_mode mode); + ansicolor_sink(FILE *target_file, color_mode mode); ~ansicolor_sink() override = default; ansicolor_sink(const ansicolor_sink &other) = delete; @@ -77,12 +77,11 @@ private: void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end); }; - template class ansicolor_stdout_sink : public ansicolor_sink { public: - explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); + explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); }; template @@ -92,7 +91,6 @@ public: explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); }; - using ansicolor_stdout_sink_mt = ansicolor_stdout_sink; using ansicolor_stdout_sink_st = ansicolor_stdout_sink; diff --git a/include/spdlog/sinks/wincolor_sink-inl.h b/include/spdlog/sinks/wincolor_sink-inl.h index 6ee2c724..12c772cc 100644 --- a/include/spdlog/sinks/wincolor_sink-inl.h +++ b/include/spdlog/sinks/wincolor_sink-inl.h @@ -125,7 +125,6 @@ void SPDLOG_INLINE wincolor_sink::print_range_(const fmt::memory_b ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr); } - // wincolor_stdout_sink template SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) @@ -138,6 +137,5 @@ SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mod : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} - } // namespace sinks } // namespace spdlog \ No newline at end of file diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index 82a551e2..94a84912 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -62,14 +62,14 @@ template class wincolor_stdout_sink : public wincolor_sink { public: - explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); + explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); }; template class wincolor_stderr_sink : public wincolor_sink { public: - explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); + explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); }; using wincolor_stdout_sink_mt = wincolor_stdout_sink; diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp index 24561ddb..f9d23d2a 100644 --- a/tests/test_pattern_formatter.cpp +++ b/tests/test_pattern_formatter.cpp @@ -264,14 +264,12 @@ static const char *test_path = "\\a\\b\\myfile.cpp"; static const char *test_path = "/a/b//myfile.cpp"; #endif - - TEST_CASE("short filename formatter-1", "[pattern_formatter]") { spdlog::pattern_formatter formatter("%s", spdlog::pattern_time_type::local, ""); fmt::memory_buffer formatted; std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{test_path , 123, "some_func()"}; + spdlog::source_loc source_loc{test_path, 123, "some_func()"}; spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); formatter.format(msg, formatted); REQUIRE(fmt::to_string(formatted) == "myfile.cpp"); @@ -304,9 +302,8 @@ TEST_CASE("full filename formatter", "[pattern_formatter]") spdlog::pattern_formatter formatter("%g", spdlog::pattern_time_type::local, ""); fmt::memory_buffer formatted; std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{test_path , 123, "some_func()"}; + spdlog::source_loc source_loc{test_path, 123, "some_func()"}; spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); formatter.format(msg, formatted); REQUIRE(fmt::to_string(formatted) == test_path); } -