From 5a4b08ec91feccb0979ff01acd731274b1ca3145 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 7 Jun 2020 23:33:47 +0300 Subject: [PATCH] Removed SPDLOG_INLINE macro --- include/spdlog/common.h | 9 ------ src/async_logger.cpp | 14 ++++----- src/common.cpp | 16 +++++----- src/details/file_helper.cpp | 18 +++++------ src/details/helpers.cpp | 2 +- src/details/log_msg.cpp | 9 +++--- src/details/log_msg_buffer.cpp | 12 ++++---- src/details/os.cpp | 50 +++++++++++++++--------------- src/details/periodic_worker.cpp | 4 +-- src/details/registry.cpp | 52 ++++++++++++++++---------------- src/details/thread_pool.cpp | 18 +++++------ src/logger.cpp | 42 +++++++++++++------------- src/pattern_formatter.cpp | 19 ++++++------ src/sinks/ansicolor_sink.cpp | 26 ++++++++-------- src/sinks/base_sink.cpp | 16 +++++----- src/sinks/basic_file_sink.cpp | 8 ++--- src/sinks/rotating_file_sink.cpp | 15 +++++---- src/sinks/sink.cpp | 6 ++-- src/sinks/stdout_color_sinks.cpp | 8 ++--- src/sinks/stdout_sinks.cpp | 22 +++++++------- src/sinks/wincolor_sink.cpp | 26 ++++++++-------- src/spdlog.cpp | 34 ++++++++++----------- 22 files changed, 207 insertions(+), 219 deletions(-) diff --git a/include/spdlog/common.h b/include/spdlog/common.h index a29ed507..b104c7cb 100644 --- a/include/spdlog/common.h +++ b/include/spdlog/common.h @@ -22,19 +22,10 @@ #endif #else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB) #define SPDLOG_API -#define SPDLOG_INLINE #endif #include -#if defined(__GNUC__) || defined(__clang__) -#define SPDLOG_DEPRECATED __attribute__((deprecated)) -#elif defined(_MSC_VER) -#define SPDLOG_DEPRECATED __declspec(deprecated) -#else -#define SPDLOG_DEPRECATED -#endif - // disable thread local on msvc 2013 #ifndef SPDLOG_NO_TLS #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) diff --git a/src/async_logger.cpp b/src/async_logger.cpp index 7aa562c4..041d5a0c 100644 --- a/src/async_logger.cpp +++ b/src/async_logger.cpp @@ -8,18 +8,18 @@ #include #include -SPDLOG_INLINE spdlog::async_logger::async_logger( +spdlog::async_logger::async_logger( std::string logger_name, sinks_init_list sinks_list, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) {} -SPDLOG_INLINE spdlog::async_logger::async_logger( +spdlog::async_logger::async_logger( std::string logger_name, sink_ptr single_sink, std::weak_ptr tp, async_overflow_policy overflow_policy) : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} // send the log message to the thread pool -SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg) +void spdlog::async_logger::sink_it_(const details::log_msg &msg) { if (auto pool_ptr = thread_pool_.lock()) { @@ -32,7 +32,7 @@ SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg) } // send flush request to the thread pool -SPDLOG_INLINE void spdlog::async_logger::flush_() +void spdlog::async_logger::flush_() { if (auto pool_ptr = thread_pool_.lock()) { @@ -47,7 +47,7 @@ SPDLOG_INLINE void spdlog::async_logger::flush_() // // backend functions - called from the thread pool to do the actual job // -SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) +void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { for (auto &sink : sinks_) { @@ -67,7 +67,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg } } -SPDLOG_INLINE void spdlog::async_logger::backend_flush_() +void spdlog::async_logger::backend_flush_() { for (auto &sink : sinks_) { @@ -79,7 +79,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_flush_() } } -SPDLOG_INLINE 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); diff --git a/src/common.cpp b/src/common.cpp index 3c788a14..0b8b30b3 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -9,17 +9,17 @@ static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; -SPDLOG_INLINE string_view_t &to_string_view(spdlog::level::level_enum l) noexcept +string_view_t &to_string_view(spdlog::level::level_enum l) noexcept { return level_string_views[l]; } -SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) noexcept +const char *to_short_c_str(spdlog::level::level_enum l) noexcept { return short_level_names[l]; } -SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) noexcept +spdlog::level::level_enum from_str(const std::string &name) noexcept { int level = 0; for (const auto &level_str : level_string_views) @@ -43,28 +43,28 @@ SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) noexce } } // namespace level -SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) +spdlog_ex::spdlog_ex(std::string msg) : msg_(std::move(msg)) {} -SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) +spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) { memory_buf_t outbuf; fmt::format_system_error(outbuf, last_errno, msg); msg_ = fmt::to_string(outbuf); } -SPDLOG_INLINE const char *spdlog_ex::what() const noexcept +const char *spdlog_ex::what() const noexcept { return msg_.c_str(); } -SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) +void throw_spdlog_ex(const std::string &msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); } -SPDLOG_INLINE void throw_spdlog_ex(std::string msg) +void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } diff --git a/src/details/file_helper.cpp b/src/details/file_helper.cpp index b9ca8426..3f13aed2 100644 --- a/src/details/file_helper.cpp +++ b/src/details/file_helper.cpp @@ -15,12 +15,12 @@ namespace spdlog { namespace details { -SPDLOG_INLINE file_helper::~file_helper() +file_helper::~file_helper() { close(); } -SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) +void file_helper::open(const filename_t &fname, bool truncate) { close(); filename_ = fname; @@ -41,7 +41,7 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno); } -SPDLOG_INLINE void file_helper::reopen(bool truncate) +void file_helper::reopen(bool truncate) { if (filename_.empty()) { @@ -50,12 +50,12 @@ SPDLOG_INLINE void file_helper::reopen(bool truncate) this->open(filename_, truncate); } -SPDLOG_INLINE void file_helper::flush() +void file_helper::flush() { std::fflush(fd_); } -SPDLOG_INLINE void file_helper::close() +void file_helper::close() { if (fd_ != nullptr) { @@ -64,7 +64,7 @@ SPDLOG_INLINE void file_helper::close() } } -SPDLOG_INLINE 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(); @@ -74,7 +74,7 @@ SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) } } -SPDLOG_INLINE size_t file_helper::size() const +size_t file_helper::size() const { if (fd_ == nullptr) { @@ -83,7 +83,7 @@ SPDLOG_INLINE size_t file_helper::size() const return os::filesize(fd_); } -SPDLOG_INLINE const filename_t &file_helper::filename() const +const filename_t &file_helper::filename() const { return filename_; } @@ -101,7 +101,7 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const // ".mylog" => (".mylog". "") // "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") -SPDLOG_INLINE std::tuple file_helper::split_by_extension(const filename_t &fname) +std::tuple file_helper::split_by_extension(const filename_t &fname) { auto ext_index = fname.rfind('.'); diff --git a/src/details/helpers.cpp b/src/details/helpers.cpp index 40fd00c7..8ff3e5ce 100644 --- a/src/details/helpers.cpp +++ b/src/details/helpers.cpp @@ -73,7 +73,7 @@ inline std::unordered_map extract_key_vals_(const std: return rv; } -SPDLOG_INLINE log_levels extract_levels(const std::string &input) +log_levels extract_levels(const std::string &input) { auto key_vals = extract_key_vals_(input); log_levels rv; diff --git a/src/details/log_msg.cpp b/src/details/log_msg.cpp index 8bb70a67..25632dc0 100644 --- a/src/details/log_msg.cpp +++ b/src/details/log_msg.cpp @@ -7,8 +7,8 @@ namespace spdlog { namespace details { -SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, - spdlog::level::level_enum lvl, spdlog::string_view_t msg) +log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, + spdlog::string_view_t msg) : logger_name(a_logger_name) , level(lvl) , time(log_time) @@ -19,12 +19,11 @@ SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::s , payload(msg) {} -SPDLOG_INLINE log_msg::log_msg( - spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) +log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} -SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) +log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg) : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} diff --git a/src/details/log_msg_buffer.cpp b/src/details/log_msg_buffer.cpp index 81343673..f4276ed8 100644 --- a/src/details/log_msg_buffer.cpp +++ b/src/details/log_msg_buffer.cpp @@ -6,7 +6,7 @@ namespace spdlog { namespace details { -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) +log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) : log_msg{orig_msg} { buffer.append(logger_name.begin(), logger_name.end()); @@ -14,7 +14,7 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) update_string_views(); } -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) +log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) : log_msg{other} { buffer.append(logger_name.begin(), logger_name.end()); @@ -22,14 +22,14 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) update_string_views(); } -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept +log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept : log_msg{other} , buffer{std::move(other.buffer)} { update_string_views(); } -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) +log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) { log_msg::operator=(other); buffer.clear(); @@ -38,7 +38,7 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot return *this; } -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept +log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) noexcept { log_msg::operator=(other); buffer = std::move(other.buffer); @@ -46,7 +46,7 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) return *this; } -SPDLOG_INLINE 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 0390857e..310f1356 100644 --- a/src/details/os.cpp +++ b/src/details/os.cpp @@ -63,7 +63,7 @@ namespace spdlog { namespace details { namespace os { -SPDLOG_INLINE spdlog::log_clock::time_point now() noexcept +spdlog::log_clock::time_point now() noexcept { #if defined __linux__ && defined SPDLOG_CLOCK_COARSE @@ -76,7 +76,7 @@ SPDLOG_INLINE spdlog::log_clock::time_point now() noexcept return log_clock::now(); #endif } -SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) noexcept +std::tm localtime(const std::time_t &time_tt) noexcept { #ifdef _WIN32 @@ -89,13 +89,13 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) noexcept return tm; } -SPDLOG_INLINE std::tm localtime() noexcept +std::tm localtime() noexcept { std::time_t now_t = ::time(nullptr); return localtime(now_t); } -SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) noexcept +std::tm gmtime(const std::time_t &time_tt) noexcept { #ifdef _WIN32 @@ -108,14 +108,14 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) noexcept return tm; } -SPDLOG_INLINE 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 -SPDLOG_INLINE 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 @@ -155,7 +155,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename return *fp == nullptr; } -SPDLOG_INLINE 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()); @@ -164,12 +164,12 @@ SPDLOG_INLINE int remove(const filename_t &filename) noexcept #endif } -SPDLOG_INLINE int remove_if_exists(const filename_t &filename) noexcept +int remove_if_exists(const filename_t &filename) noexcept { return path_exists(filename) ? remove(filename) : 0; } -SPDLOG_INLINE 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()); @@ -179,7 +179,7 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename } // Return true if path exists (file or directory) -SPDLOG_INLINE bool path_exists(const filename_t &filename) noexcept +bool path_exists(const filename_t &filename) noexcept { #ifdef _WIN32 #ifdef SPDLOG_WCHAR_FILENAMES @@ -195,7 +195,7 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) noexcept } // Return file size according to open FILE* object -SPDLOG_INLINE size_t filesize(FILE *f) +size_t filesize(FILE *f) { if (f == nullptr) { @@ -245,7 +245,7 @@ SPDLOG_INLINE size_t filesize(FILE *f) } // Return utc offset in minutes or throw spdlog_ex on failure -SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) +int utc_minutes_offset(const std::tm &tm) { #ifdef _WIN32 @@ -312,7 +312,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) // Return current thread id as size_t // It exists because the std::this_thread::get_id() is much slower(especially // under VS 2013) -SPDLOG_INLINE size_t _thread_id() noexcept +size_t _thread_id() noexcept { #ifdef _WIN32 return static_cast(::GetCurrentThreadId()); @@ -339,7 +339,7 @@ SPDLOG_INLINE size_t _thread_id() noexcept } // Return current thread id as size_t (from thread local storage) -SPDLOG_INLINE size_t thread_id() noexcept +size_t thread_id() noexcept { #if defined(SPDLOG_NO_TLS) return _thread_id(); @@ -351,7 +351,7 @@ SPDLOG_INLINE 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 -SPDLOG_INLINE void sleep_for_millis(int milliseconds) noexcept +void sleep_for_millis(int milliseconds) noexcept { #if defined(_WIN32) ::Sleep(milliseconds); @@ -362,20 +362,20 @@ SPDLOG_INLINE void sleep_for_millis(int milliseconds) noexcept // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) +std::string filename_to_str(const filename_t &filename) { memory_buf_t buf; wstr_to_utf8buf(filename, buf); return fmt::to_string(buf); } #else -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) +std::string filename_to_str(const filename_t &filename) { return filename; } #endif -SPDLOG_INLINE int pid() noexcept +int pid() noexcept { #ifdef _WIN32 @@ -387,7 +387,7 @@ SPDLOG_INLINE int pid() noexcept // Determine if the terminal supports colors // Based on: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool is_color_terminal() noexcept +bool is_color_terminal() noexcept { #ifdef _WIN32 return true; @@ -409,7 +409,7 @@ SPDLOG_INLINE bool is_color_terminal() noexcept // Determine if the terminal attached // Source: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool in_terminal(FILE *file) noexcept +bool in_terminal(FILE *file) noexcept { #ifdef _WIN32 @@ -420,7 +420,7 @@ SPDLOG_INLINE bool in_terminal(FILE *file) noexcept } #if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) -SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) +void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) { if (wstr.size() > static_cast((std::numeric_limits::max)())) { @@ -457,7 +457,7 @@ SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) // return true on success -static SPDLOG_INLINE bool mkdir_(const filename_t &path) +static bool mkdir_(const filename_t &path) { #ifdef _WIN32 #ifdef SPDLOG_WCHAR_FILENAMES @@ -472,7 +472,7 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path) // create the given directory - and all directories leading to it // return true on success or if the directory already exists -SPDLOG_INLINE bool create_dir(filename_t path) +bool create_dir(filename_t path) { if (path_exists(path)) { @@ -516,7 +516,7 @@ SPDLOG_INLINE bool create_dir(filename_t path) // "abc/" => "abc" // "abc" => "" // "abc///" => "abc//" -SPDLOG_INLINE filename_t dir_name(filename_t path) +filename_t dir_name(filename_t path) { #ifdef _WIN32 // support forward slash in windows @@ -526,7 +526,7 @@ SPDLOG_INLINE filename_t dir_name(filename_t path) return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; } -std::string SPDLOG_INLINE getenv(const char *field) +std::string getenv(const char *field) { #if defined(_MSC_VER) diff --git a/src/details/periodic_worker.cpp b/src/details/periodic_worker.cpp index 8e474400..6c4d59c8 100644 --- a/src/details/periodic_worker.cpp +++ b/src/details/periodic_worker.cpp @@ -6,7 +6,7 @@ namespace spdlog { namespace details { -SPDLOG_INLINE periodic_worker::periodic_worker(const std::function &callback_fun, std::chrono::seconds interval) +periodic_worker::periodic_worker(const std::function &callback_fun, std::chrono::seconds interval) { active_ = (interval > std::chrono::seconds::zero()); if (!active_) @@ -28,7 +28,7 @@ SPDLOG_INLINE periodic_worker::periodic_worker(const std::function &call } // stop the worker thread and join it -SPDLOG_INLINE periodic_worker::~periodic_worker() +periodic_worker::~periodic_worker() { if (worker_thread_.joinable()) { diff --git a/src/details/registry.cpp b/src/details/registry.cpp index 222a2235..254b0127 100644 --- a/src/details/registry.cpp +++ b/src/details/registry.cpp @@ -25,7 +25,7 @@ namespace spdlog { namespace details { -SPDLOG_INLINE registry::registry() +registry::registry() : formatter_(new pattern_formatter()) { @@ -44,15 +44,15 @@ SPDLOG_INLINE registry::registry() #endif // SPDLOG_DISABLE_DEFAULT_LOGGER } -SPDLOG_INLINE registry::~registry() = default; +registry::~registry() = default; -SPDLOG_INLINE 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)); } -SPDLOG_INLINE 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()); @@ -71,14 +71,14 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logge } } -SPDLOG_INLINE 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; } -SPDLOG_INLINE std::shared_ptr registry::default_logger() +std::shared_ptr registry::default_logger() { std::lock_guard lock(logger_map_mutex_); return default_logger_; @@ -88,14 +88,14 @@ SPDLOG_INLINE std::shared_ptr registry::default_logger() // To be used directly by the spdlog default api (e.g. spdlog::info) // This make the default API faster, but cannot be used concurrently with set_default_logger(). // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. -SPDLOG_INLINE logger *registry::get_default_raw() +logger *registry::get_default_raw() { return default_logger_.get(); } // set default logger. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. -SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) +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 @@ -110,20 +110,20 @@ SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_defa default_logger_ = std::move(new_default_logger); } -SPDLOG_INLINE 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); } -SPDLOG_INLINE 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 -SPDLOG_INLINE 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); @@ -133,7 +133,7 @@ SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) } } -SPDLOG_INLINE void registry::set_level(level::level_enum log_level) +void registry::set_level(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) @@ -143,7 +143,7 @@ SPDLOG_INLINE void registry::set_level(level::level_enum log_level) levels_.set_default(log_level); } -SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) +void registry::flush_on(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) @@ -153,14 +153,14 @@ SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) flush_level_ = log_level; } -SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval) +void registry::flush_every(std::chrono::seconds interval) { std::lock_guard lock(flusher_mutex_); auto clbk = [this]() { this->flush_all(); }; periodic_flusher_ = std::make_unique(clbk, interval); } -SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg)) +void registry::set_error_handler(void (*handler)(const std::string &msg)) { std::lock_guard lock(logger_map_mutex_); for (auto &l : loggers_) @@ -170,7 +170,7 @@ SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string err_handler_ = handler; } -SPDLOG_INLINE 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_) @@ -179,7 +179,7 @@ SPDLOG_INLINE void registry::apply_all(const std::function lock(logger_map_mutex_); for (auto &l : loggers_) @@ -188,7 +188,7 @@ SPDLOG_INLINE void registry::flush_all() } } -SPDLOG_INLINE void registry::drop(const std::string &logger_name) +void registry::drop(const std::string &logger_name) { std::lock_guard lock(logger_map_mutex_); loggers_.erase(logger_name); @@ -198,7 +198,7 @@ SPDLOG_INLINE void registry::drop(const std::string &logger_name) } } -SPDLOG_INLINE void registry::drop_all() +void registry::drop_all() { std::lock_guard lock(logger_map_mutex_); loggers_.clear(); @@ -206,7 +206,7 @@ SPDLOG_INLINE void registry::drop_all() } // clean all resources and threads started by the registry -SPDLOG_INLINE void registry::shutdown() +void registry::shutdown() { { std::lock_guard lock(flusher_mutex_); @@ -221,18 +221,18 @@ SPDLOG_INLINE void registry::shutdown() } } -SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() +std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } -SPDLOG_INLINE 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; } -SPDLOG_INLINE void registry::update_levels(cfg::log_levels levels) +void registry::update_levels(cfg::log_levels levels) { std::lock_guard lock(logger_map_mutex_); levels_ = std::move(levels); @@ -243,13 +243,13 @@ SPDLOG_INLINE void registry::update_levels(cfg::log_levels levels) } } -SPDLOG_INLINE registry ®istry::instance() +registry ®istry::instance() { static registry s_instance; return s_instance; } -SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) +void registry::throw_if_exists_(const std::string &logger_name) { if (loggers_.find(logger_name) != loggers_.end()) { @@ -257,7 +257,7 @@ SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) } } -SPDLOG_INLINE 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); diff --git a/src/details/thread_pool.cpp b/src/details/thread_pool.cpp index db9ac130..2d143f34 100644 --- a/src/details/thread_pool.cpp +++ b/src/details/thread_pool.cpp @@ -8,7 +8,7 @@ namespace spdlog { namespace details { -SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start) +thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function on_thread_start) : q_(q_max_items) { if (threads_n == 0 || threads_n > 1000) @@ -25,12 +25,12 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std } } -SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) +thread_pool::thread_pool(size_t q_max_items, size_t threads_n) : thread_pool(q_max_items, threads_n, [] {}) {} // message all threads to terminate gracefully join them -SPDLOG_INLINE thread_pool::~thread_pool() +thread_pool::~thread_pool() { SPDLOG_TRY { @@ -47,23 +47,23 @@ SPDLOG_INLINE thread_pool::~thread_pool() SPDLOG_CATCH_ALL() {} } -void SPDLOG_INLINE 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 SPDLOG_INLINE 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 SPDLOG_INLINE thread_pool::overrun_counter() +size_t thread_pool::overrun_counter() { return q_.overrun_counter(); } -void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) +void thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) { if (overflow_policy == async_overflow_policy::block) { @@ -75,7 +75,7 @@ void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overf } } -void SPDLOG_INLINE thread_pool::worker_loop_() +void thread_pool::worker_loop_() { while (process_next_msg_()) {} } @@ -83,7 +83,7 @@ void SPDLOG_INLINE thread_pool::worker_loop_() // process next message in the queue // return true if this thread should still be active (while no terminate msg // was received) -bool SPDLOG_INLINE thread_pool::process_next_msg_() +bool thread_pool::process_next_msg_() { async_msg incoming_async_msg; bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10)); diff --git a/src/logger.cpp b/src/logger.cpp index a35a5708..336f1da0 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -12,7 +12,7 @@ namespace spdlog { // public methods -SPDLOG_INLINE logger::logger(const logger &other) +logger::logger(const logger &other) : name_(other.name_) , sinks_(other.sinks_) , level_(other.level_.load(std::memory_order_relaxed)) @@ -20,7 +20,7 @@ SPDLOG_INLINE logger::logger(const logger &other) , custom_err_handler_(other.custom_err_handler_) {} -SPDLOG_INLINE logger::logger(logger &&other) noexcept +logger::logger(logger &&other) noexcept : name_(std::move(other.name_)) , sinks_(std::move(other.sinks_)) , level_(other.level_.load(std::memory_order_relaxed)) @@ -28,13 +28,13 @@ SPDLOG_INLINE logger::logger(logger &&other) noexcept , custom_err_handler_(std::move(other.custom_err_handler_)) {} -SPDLOG_INLINE logger &logger::operator=(logger other) noexcept +logger &logger::operator=(logger other) noexcept { this->swap(other); return *this; } -SPDLOG_INLINE void logger::swap(spdlog::logger &other) noexcept +void logger::swap(spdlog::logger &other) noexcept { name_.swap(other.name_); sinks_.swap(other.sinks_); @@ -50,29 +50,29 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) noexcept custom_err_handler_.swap(other.custom_err_handler_); } -SPDLOG_INLINE void swap(logger &a, logger &b) +void swap(logger &a, logger &b) { a.swap(b); } -SPDLOG_INLINE void logger::set_level(level::level_enum log_level) +void logger::set_level(level::level_enum log_level) { level_.store(log_level); } -SPDLOG_INLINE level::level_enum logger::level() const +level::level_enum logger::level() const { return static_cast(level_.load(std::memory_order_relaxed)); } -SPDLOG_INLINE const std::string &logger::name() const +const std::string &logger::name() const { return name_; } // set formatting for the sinks in this logger. // each sink will get a separate instance of the formatter object. -SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) +void logger::set_formatter(std::unique_ptr f) { for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { @@ -89,54 +89,54 @@ SPDLOG_INLINE void logger::set_formatter(std::unique_ptr f) } } -SPDLOG_INLINE 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 -SPDLOG_INLINE void logger::flush() +void logger::flush() { flush_(); } -SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) +void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } -SPDLOG_INLINE level::level_enum logger::flush_level() const +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 +const std::vector &logger::sinks() const { return sinks_; } -SPDLOG_INLINE std::vector &logger::sinks() +std::vector &logger::sinks() { return sinks_; } // error handler -SPDLOG_INLINE void logger::set_error_handler(err_handler handler) +void logger::set_error_handler(err_handler handler) { custom_err_handler_ = std::move(handler); } // create new logger with same sinks and configuration. -SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) +std::shared_ptr logger::clone(std::string logger_name) { auto cloned = std::make_shared(*this); cloned->name_ = std::move(logger_name); return cloned; } -SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) +void logger::sink_it_(const details::log_msg &msg) { for (auto &sink : sinks_) { @@ -156,7 +156,7 @@ SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) } } -SPDLOG_INLINE void logger::flush_() +void logger::flush_() { for (auto &sink : sinks_) { @@ -168,13 +168,13 @@ SPDLOG_INLINE void logger::flush_() } } -SPDLOG_INLINE 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.level >= flush_level) && (msg.level != level::off); } -SPDLOG_INLINE void logger::err_handler_(const std::string &msg) +void logger::err_handler_(const std::string &msg) { if (custom_err_handler_) { diff --git a/src/pattern_formatter.cpp b/src/pattern_formatter.cpp index d842f659..3abca528 100644 --- a/src/pattern_formatter.cpp +++ b/src/pattern_formatter.cpp @@ -987,8 +987,7 @@ private: } // namespace details -SPDLOG_INLINE pattern_formatter::pattern_formatter( - std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags) +pattern_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) @@ -1000,7 +999,7 @@ SPDLOG_INLINE pattern_formatter::pattern_formatter( } // use by default full formatter for if pattern is not given -SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) +pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) : pattern_("%+") , eol_(std::move(eol)) , pattern_time_type_(time_type) @@ -1010,7 +1009,7 @@ SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, formatters_.push_back(std::make_unique(details::padding_info{})); } -SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const +std::unique_ptr pattern_formatter::clone() const { custom_flags cloned_custom_formatters; for (auto &it : custom_handlers_) @@ -1020,7 +1019,7 @@ SPDLOG_INLINE std::unique_ptr pattern_formatter::clone() const return std::make_unique(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters)); } -SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) +void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) { auto secs = std::chrono::duration_cast(msg.time.time_since_epoch()); if (secs != last_log_secs_) @@ -1037,13 +1036,13 @@ SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory details::fmt_helper::append_string_view(eol_, dest); } -SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) +void pattern_formatter::set_pattern(std::string pattern) { pattern_ = std::move(pattern); compile_pattern_(pattern_); } -SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) +std::tm pattern_formatter::get_time_(const details::log_msg &msg) { if (pattern_time_type_ == pattern_time_type::local) { @@ -1053,7 +1052,7 @@ SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) } template -SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) +void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { // process custom flags auto it = custom_handlers_.find(flag); @@ -1251,7 +1250,7 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) // Advance the given it pass the end of the padding spec found (if any) // Return padding. -SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end) +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; @@ -1304,7 +1303,7 @@ SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::stri return details::padding_info{std::min(width, max_width), side, truncate}; } -SPDLOG_INLINE 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; diff --git a/src/sinks/ansicolor_sink.cpp b/src/sinks/ansicolor_sink.cpp index c01474dd..e36e2ba7 100644 --- a/src/sinks/ansicolor_sink.cpp +++ b/src/sinks/ansicolor_sink.cpp @@ -12,7 +12,7 @@ namespace spdlog { namespace sinks { template -SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) +ansicolor_sink::ansicolor_sink(FILE *target_file, color_mode mode) : target_file_(target_file) , mutex_(ConsoleMutex::mutex()) , formatter_(std::make_unique()) @@ -29,14 +29,14 @@ SPDLOG_INLINE ansicolor_sink::ansicolor_sink(FILE *target_file, co } template -SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) +void ansicolor_sink::set_color(level::level_enum color_level, string_view_t color) { std::lock_guard lock(mutex_); colors_[color_level] = to_string_(color); } template -SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) +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. @@ -64,34 +64,34 @@ SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg } template -SPDLOG_INLINE void ansicolor_sink::flush() +void ansicolor_sink::flush() { std::lock_guard lock(mutex_); fflush(target_file_); } template -SPDLOG_INLINE void ansicolor_sink::set_pattern(const std::string &pattern) +void ansicolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template -SPDLOG_INLINE void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) +void ansicolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } template -SPDLOG_INLINE bool ansicolor_sink::should_color() +bool ansicolor_sink::should_color() { return should_do_colors_; } template -SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) +void ansicolor_sink::set_color_mode(color_mode mode) { switch (mode) { @@ -108,32 +108,32 @@ SPDLOG_INLINE void ansicolor_sink::set_color_mode(color_mode mode) } template -SPDLOG_INLINE void ansicolor_sink::print_ccode_(const string_view_t &color_code) +void ansicolor_sink::print_ccode_(const string_view_t &color_code) { fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); } template -SPDLOG_INLINE void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) +void ansicolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); } template -SPDLOG_INLINE std::string ansicolor_sink::to_string_(const string_view_t &sv) +std::string ansicolor_sink::to_string_(const string_view_t &sv) { return std::string(sv.data(), sv.size()); } // ansicolor_stdout_sink template -SPDLOG_INLINE ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) +ansicolor_stdout_sink::ansicolor_stdout_sink(color_mode mode) : ansicolor_sink(stdout, mode) {} // ansicolor_stderr_sink template -SPDLOG_INLINE ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) +ansicolor_stderr_sink::ansicolor_stderr_sink(color_mode mode) : ansicolor_sink(stderr, mode) {} diff --git a/src/sinks/base_sink.cpp b/src/sinks/base_sink.cpp index 6016749c..8fd7d11b 100644 --- a/src/sinks/base_sink.cpp +++ b/src/sinks/base_sink.cpp @@ -9,51 +9,51 @@ #include template -SPDLOG_INLINE spdlog::sinks::base_sink::base_sink() +spdlog::sinks::base_sink::base_sink() : formatter_{std::make_unique()} {} template -SPDLOG_INLINE spdlog::sinks::base_sink::base_sink(std::unique_ptr formatter) +spdlog::sinks::base_sink::base_sink(std::unique_ptr formatter) : formatter_{std::move(formatter)} {} template -void SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg &msg) +void spdlog::sinks::base_sink::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); sink_it_(msg); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::flush() +void spdlog::sinks::base_sink::flush() { std::lock_guard lock(mutex_); flush_(); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_pattern(const std::string &pattern) +void spdlog::sinks::base_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); set_pattern_(pattern); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter(std::unique_ptr sink_formatter) +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_INLINE spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) +void spdlog::sinks::base_sink::set_pattern_(const std::string &pattern) { set_formatter_(std::make_unique(pattern)); } template -void SPDLOG_INLINE spdlog::sinks::base_sink::set_formatter_(std::unique_ptr sink_formatter) +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 c7194dee..0b570053 100644 --- a/src/sinks/basic_file_sink.cpp +++ b/src/sinks/basic_file_sink.cpp @@ -9,19 +9,19 @@ namespace spdlog { namespace sinks { template -SPDLOG_INLINE basic_file_sink::basic_file_sink(const filename_t &filename, bool truncate) +basic_file_sink::basic_file_sink(const filename_t &filename, bool truncate) { file_helper_.open(filename, truncate); } template -SPDLOG_INLINE const filename_t &basic_file_sink::filename() const +const filename_t &basic_file_sink::filename() const { return file_helper_.filename(); } template -SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) +void basic_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); @@ -29,7 +29,7 @@ SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) } template -SPDLOG_INLINE void basic_file_sink::flush_() +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 ac5cc33f..c595acd5 100644 --- a/src/sinks/rotating_file_sink.cpp +++ b/src/sinks/rotating_file_sink.cpp @@ -19,8 +19,7 @@ namespace spdlog { namespace sinks { template -SPDLOG_INLINE rotating_file_sink::rotating_file_sink( - filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open) +rotating_file_sink::rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open) : base_filename_(std::move(base_filename)) , max_size_(max_size) , max_files_(max_files) @@ -36,7 +35,7 @@ SPDLOG_INLINE rotating_file_sink::rotating_file_sink( // calc filename according to index and file extension if exists. // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". template -SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) +filename_t rotating_file_sink::calc_filename(const filename_t &filename, std::size_t index) { if (index == 0u) { @@ -49,14 +48,14 @@ SPDLOG_INLINE filename_t rotating_file_sink::calc_filename(const filename } template -SPDLOG_INLINE filename_t rotating_file_sink::filename() +filename_t rotating_file_sink::filename() { std::lock_guard lock(base_sink::mutex_); return file_helper_.filename(); } template -SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) +void rotating_file_sink::sink_it_(const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); @@ -70,7 +69,7 @@ SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &m } template -SPDLOG_INLINE void rotating_file_sink::flush_() +void rotating_file_sink::flush_() { file_helper_.flush(); } @@ -81,7 +80,7 @@ SPDLOG_INLINE void rotating_file_sink::flush_() // log.2.txt -> log.3.txt // log.3.txt -> delete template -SPDLOG_INLINE void rotating_file_sink::rotate_() +void rotating_file_sink::rotate_() { using details::os::filename_to_str; using details::os::path_exists; @@ -115,7 +114,7 @@ SPDLOG_INLINE void rotating_file_sink::rotate_() // delete the target if exists, and rename the src file to target // return true on success, false otherwise. template -SPDLOG_INLINE bool rotating_file_sink::rename_file_(const filename_t &src_filename, const filename_t &target_filename) +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); diff --git a/src/sinks/sink.cpp b/src/sinks/sink.cpp index 20fa9ed0..add9d73c 100644 --- a/src/sinks/sink.cpp +++ b/src/sinks/sink.cpp @@ -4,17 +4,17 @@ #include #include -SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const +bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { return msg_level >= level_.load(std::memory_order_relaxed); } -SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) +void spdlog::sinks::sink::set_level(level::level_enum log_level) { level_.store(log_level, std::memory_order_relaxed); } -SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const +spdlog::level::level_enum spdlog::sinks::sink::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 b3638bdd..9c63e834 100644 --- a/src/sinks/stdout_color_sinks.cpp +++ b/src/sinks/stdout_color_sinks.cpp @@ -10,25 +10,25 @@ namespace spdlog { template -SPDLOG_INLINE std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) +std::shared_ptr stdout_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template -SPDLOG_INLINE std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) +std::shared_ptr stdout_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template -SPDLOG_INLINE std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) +std::shared_ptr stderr_color_mt(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } template -SPDLOG_INLINE std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) +std::shared_ptr stderr_color_st(const std::string &logger_name, color_mode mode) { return Factory::template create(logger_name, mode); } diff --git a/src/sinks/stdout_sinks.cpp b/src/sinks/stdout_sinks.cpp index 67c121a0..527af05d 100644 --- a/src/sinks/stdout_sinks.cpp +++ b/src/sinks/stdout_sinks.cpp @@ -15,14 +15,14 @@ namespace spdlog { namespace sinks { template -SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) +stdout_sink_base::stdout_sink_base(FILE *file) : mutex_(ConsoleMutex::mutex()) , file_(file) , formatter_(std::make_unique()) {} template -SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) +void stdout_sink_base::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); memory_buf_t formatted; @@ -32,21 +32,21 @@ SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &m } template -SPDLOG_INLINE void stdout_sink_base::flush() +void stdout_sink_base::flush() { std::lock_guard lock(mutex_); fflush(file_); } template -SPDLOG_INLINE void stdout_sink_base::set_pattern(const std::string &pattern) +void stdout_sink_base::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template -SPDLOG_INLINE void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) +void stdout_sink_base::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); @@ -54,13 +54,13 @@ SPDLOG_INLINE void stdout_sink_base::set_formatter(std::unique_ptr // stdout sink template -SPDLOG_INLINE stdout_sink::stdout_sink() +stdout_sink::stdout_sink() : stdout_sink_base(stdout) {} // stderr sink template -SPDLOG_INLINE stderr_sink::stderr_sink() +stderr_sink::stderr_sink() : stdout_sink_base(stderr) {} @@ -68,25 +68,25 @@ SPDLOG_INLINE stderr_sink::stderr_sink() // factory methods template -SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) +std::shared_ptr stdout_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } template -SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) +std::shared_ptr stdout_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } template -SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) +std::shared_ptr stderr_logger_mt(const std::string &logger_name) { return Factory::template create(logger_name); } template -SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) +std::shared_ptr stderr_logger_st(const std::string &logger_name) { return Factory::template create(logger_name); } diff --git a/src/sinks/wincolor_sink.cpp b/src/sinks/wincolor_sink.cpp index 11ad9589..416d9977 100644 --- a/src/sinks/wincolor_sink.cpp +++ b/src/sinks/wincolor_sink.cpp @@ -10,7 +10,7 @@ namespace spdlog { namespace sinks { template -SPDLOG_INLINE wincolor_sink::wincolor_sink(HANDLE out_handle, color_mode mode) +wincolor_sink::wincolor_sink(HANDLE out_handle, color_mode mode) : out_handle_(out_handle) , mutex_(ConsoleMutex::mutex()) , formatter_(std::make_unique()) @@ -31,21 +31,21 @@ SPDLOG_INLINE wincolor_sink::wincolor_sink(HANDLE out_handle, colo } template -SPDLOG_INLINE wincolor_sink::~wincolor_sink() +wincolor_sink::~wincolor_sink() { this->flush(); } // change the color for the given level template -void SPDLOG_INLINE wincolor_sink::set_color(level::level_enum level, WORD color) +void wincolor_sink::set_color(level::level_enum level, WORD color) { std::lock_guard lock(mutex_); colors_[level] = color; } template -void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) +void wincolor_sink::log(const details::log_msg &msg) { std::lock_guard lock(mutex_); msg.color_range_start = 0; @@ -76,27 +76,27 @@ void SPDLOG_INLINE wincolor_sink::log(const details::log_msg &msg) } template -void SPDLOG_INLINE wincolor_sink::flush() +void wincolor_sink::flush() { // windows console always flushed? } template -void SPDLOG_INLINE wincolor_sink::set_pattern(const std::string &pattern) +void wincolor_sink::set_pattern(const std::string &pattern) { std::lock_guard lock(mutex_); formatter_ = std::unique_ptr(new pattern_formatter(pattern)); } template -void SPDLOG_INLINE wincolor_sink::set_formatter(std::unique_ptr sink_formatter) +void wincolor_sink::set_formatter(std::unique_ptr sink_formatter) { std::lock_guard lock(mutex_); formatter_ = std::move(sink_formatter); } template -void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) +void wincolor_sink::set_color_mode(color_mode mode) { switch (mode) { @@ -114,7 +114,7 @@ void SPDLOG_INLINE wincolor_sink::set_color_mode(color_mode mode) // set foreground color and return the orig console attributes (for resetting later) template -WORD SPDLOG_INLINE wincolor_sink::set_foreground_color_(WORD attribs) +WORD wincolor_sink::set_foreground_color_(WORD attribs) { CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; ::GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info); @@ -128,14 +128,14 @@ WORD SPDLOG_INLINE wincolor_sink::set_foreground_color_(WORD attri // print a range of formatted message to console template -void SPDLOG_INLINE wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) +void wincolor_sink::print_range_(const memory_buf_t &formatted, size_t start, size_t end) { auto size = static_cast(end - start); ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr); } template -void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_t &formatted) +void wincolor_sink::write_to_file_(const memory_buf_t &formatted) { if (out_handle_ == nullptr) // no console and no file redirect { @@ -162,13 +162,13 @@ void SPDLOG_INLINE wincolor_sink::write_to_file_(const memory_buf_ // wincolor_stdout_sink template -SPDLOG_INLINE wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) +wincolor_stdout_sink::wincolor_stdout_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {} // wincolor_stderr_sink template -SPDLOG_INLINE wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) +wincolor_stderr_sink::wincolor_stderr_sink(color_mode mode) : wincolor_sink(::GetStdHandle(STD_ERROR_HANDLE), mode) {} diff --git a/src/spdlog.cpp b/src/spdlog.cpp index bdd8f57f..f06f2365 100644 --- a/src/spdlog.cpp +++ b/src/spdlog.cpp @@ -7,87 +7,87 @@ namespace spdlog { -SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) +void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } -SPDLOG_INLINE std::shared_ptr get(const std::string &name) +std::shared_ptr get(const std::string &name) { return details::registry::instance().get(name); } -SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) +void set_formatter(std::unique_ptr formatter) { details::registry::instance().set_formatter(std::move(formatter)); } -SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) +void set_pattern(std::string pattern, pattern_time_type time_type) { set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } -SPDLOG_INLINE void set_level(level::level_enum log_level) +void set_level(level::level_enum log_level) { details::registry::instance().set_level(log_level); } -SPDLOG_INLINE void flush_on(level::level_enum log_level) +void flush_on(level::level_enum log_level) { details::registry::instance().flush_on(log_level); } -SPDLOG_INLINE void flush_every(std::chrono::seconds interval) +void flush_every(std::chrono::seconds interval) { details::registry::instance().flush_every(interval); } -SPDLOG_INLINE 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); } -SPDLOG_INLINE void register_logger(std::shared_ptr logger) +void register_logger(std::shared_ptr logger) { details::registry::instance().register_logger(std::move(logger)); } -SPDLOG_INLINE void apply_all(const std::function)> &fun) +void apply_all(const std::function)> &fun) { details::registry::instance().apply_all(fun); } -SPDLOG_INLINE void drop(const std::string &name) +void drop(const std::string &name) { details::registry::instance().drop(name); } -SPDLOG_INLINE void drop_all() +void drop_all() { details::registry::instance().drop_all(); } -SPDLOG_INLINE void shutdown() +void shutdown() { details::registry::instance().shutdown(); } -SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) +void set_automatic_registration(bool automatic_registration) { details::registry::instance().set_automatic_registration(automatic_registration); } -SPDLOG_INLINE std::shared_ptr default_logger() +std::shared_ptr default_logger() { return details::registry::instance().default_logger(); } -SPDLOG_INLINE spdlog::logger *default_logger_raw() +spdlog::logger *default_logger_raw() { return details::registry::instance().get_default_raw(); } -SPDLOG_INLINE 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)); }