mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-04-01 02:42:41 +08:00
Code

Removed SPDLOG_COMPILED_LIB/HEADER_ONLY macros from common.h

Browse Source
This commit is contained in:
gabime 2023-09-24 13:02:30 +03:00
parent b16a8951bc
commit fc81e0390b
23 changed files with 247 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/spdlog/async_logger-inl.h
View File

@ -13,18 +13,18 @@
#include <memory> #include <memory>
#include <string> #include <string>
SPDLOG_INLINE spdlog::async_logger::async_logger( spdlog::async_logger::async_logger(
std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy) std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
: async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), 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<details::thread_pool> tp, async_overflow_policy overflow_policy) std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
: async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), 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 // 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)
{ {
SPDLOG_TRY SPDLOG_TRY
{ {
@ -41,7 +41,7 @@ SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
} }
// send flush request to the thread pool // send flush request to the thread pool
SPDLOG_INLINE void spdlog::async_logger::flush_() void spdlog::async_logger::flush_()
{ {
SPDLOG_TRY SPDLOG_TRY
{ {
@ -60,7 +60,7 @@ SPDLOG_INLINE void spdlog::async_logger::flush_()
// //
// backend functions - called from the thread pool to do the actual job // 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_) for (auto &sink : sinks_)
{ {
@ -80,7 +80,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_) for (auto &sink : sinks_)
{ {
@ -92,7 +92,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
} }
} }
SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
{ {
auto cloned = std::make_shared<spdlog::async_logger>(*this); auto cloned = std::make_shared<spdlog::async_logger>(*this);
cloned->name_ = std::move(new_name); cloned->name_ = std::move(new_name);

3
include/spdlog/async_logger.h
View File

@ -64,6 +64,3 @@ private:
}; };
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
# include "async_logger-inl.h"
#endif

2
include/spdlog/cfg/helpers-inl.h
View File

@ -79,7 +79,7 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
return rv; return rv;
} }
SPDLOG_INLINE void load_levels(const std::string &input) void load_levels(const std::string &input)
{ {
if (input.empty() || input.size() > 512) if (input.empty() || input.size() > 512)
{ {

12
include/spdlog/common-inl.h
View File

@ -12,7 +12,7 @@
namespace spdlog { namespace spdlog {
SPDLOG_INLINE 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); auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
if (it != std::end(level_string_views)) if (it != std::end(level_string_views))
@ -30,11 +30,11 @@ SPDLOG_INLINE spdlog::level level_from_str(const std::string &name) noexcept
return level::off; return level::off;
} }
SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) spdlog_ex::spdlog_ex(std::string msg)
: msg_(std::move(msg)) : msg_(std::move(msg))
{} {}
SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
{ {
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what();
@ -45,17 +45,17 @@ SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno)
#endif #endif
} }
SPDLOG_INLINE const char *spdlog_ex::what() const noexcept const char *spdlog_ex::what() const noexcept
{ {
return msg_.c_str(); 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_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))); SPDLOG_THROW(spdlog_ex(std::move(msg)));
} }

53
include/spdlog/common.h
View File

@ -38,27 +38,44 @@
# endif # endif
#endif #endif
#ifdef SPDLOG_COMPILED_LIB
# undef SPDLOG_HEADER_ONLY #if defined(SPDLOG_SHARED_LIB)
# if defined(SPDLOG_SHARED_LIB) # if defined(_WIN32)
# if defined(_WIN32) # ifdef spdlog_EXPORTS
# ifdef spdlog_EXPORTS # define SPDLOG_API __declspec(dllexport)
# define SPDLOG_API __declspec(dllexport) # else // !spdlog_EXPORTS
# else // !spdlog_EXPORTS # define SPDLOG_API __declspec(dllimport)
# define SPDLOG_API __declspec(dllimport)
# endif
# else // !defined(_WIN32)
# define SPDLOG_API __attribute__((visibility("default")))
# endif # endif
# else // !defined(SPDLOG_SHARED_LIB) # else // !defined(_WIN32)
# define SPDLOG_API # define SPDLOG_API __attribute__((visibility("default")))
# endif # endif
# define SPDLOG_INLINE #else // !defined(SPDLOG_SHARED_LIB)
#else // !defined(SPDLOG_COMPILED_LIB)
# define SPDLOG_API # define SPDLOG_API
# define SPDLOG_HEADER_ONLY #endif
# define SPDLOG_INLINE inline
#endif // #ifdef SPDLOG_COMPILED_LIB //
//
//#ifdef SPDLOG_COMPILED_LIB
//# undef SPDLOG_HEADER_ONLY
//# if defined(SPDLOG_SHARED_LIB)
//# if defined(_WIN32)
//# ifdef spdlog_EXPORTS
//# define SPDLOG_API __declspec(dllexport)
//# else // !spdlog_EXPORTS
//# define SPDLOG_API __declspec(dllimport)
//# endif
//# else // !defined(_WIN32)
//# define SPDLOG_API __attribute__((visibility("default")))
//# endif
//# else // !defined(SPDLOG_SHARED_LIB)
//# define SPDLOG_API
//# endif
//# define
//#else // !defined(SPDLOG_COMPILED_LIB)
//# define SPDLOG_API
//# define SPDLOG_HEADER_ONLY
//# define inline
//#endif // #ifdef SPDLOG_COMPILED_LIB
#include <spdlog/fmt/fmt.h> #include <spdlog/fmt/fmt.h>

22
include/spdlog/details/file_helper-inl.h
View File

@ -20,16 +20,16 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) file_helper::file_helper(const file_event_handlers &event_handlers)
: event_handlers_(event_handlers) : event_handlers_(event_handlers)
{} {}
SPDLOG_INLINE file_helper::~file_helper() file_helper::~file_helper()
{ {
close(); close();
} }
SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) void file_helper::open(const filename_t &fname, bool truncate)
{ {
close(); close();
filename_ = fname; filename_ = fname;
@ -73,7 +73,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); 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()) if (filename_.empty())
{ {
@ -82,7 +82,7 @@ SPDLOG_INLINE void file_helper::reopen(bool truncate)
this->open(filename_, truncate); this->open(filename_, truncate);
} }
SPDLOG_INLINE void file_helper::flush() void file_helper::flush()
{ {
if (std::fflush(fd_) != 0) if (std::fflush(fd_) != 0)
{ {
@ -90,7 +90,7 @@ SPDLOG_INLINE void file_helper::flush()
} }
} }
SPDLOG_INLINE void file_helper::sync() void file_helper::sync()
{ {
if (!os::fsync(fd_)) if (!os::fsync(fd_))
{ {
@ -98,7 +98,7 @@ SPDLOG_INLINE void file_helper::sync()
} }
} }
SPDLOG_INLINE void file_helper::close() void file_helper::close()
{ {
if (fd_ != nullptr) if (fd_ != nullptr)
{ {
@ -117,7 +117,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(); size_t msg_size = buf.size();
auto data = buf.data(); auto data = buf.data();
@ -127,7 +127,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) if (fd_ == nullptr)
{ {
@ -136,7 +136,7 @@ SPDLOG_INLINE size_t file_helper::size() const
return os::filesize(fd_); return os::filesize(fd_);
} }
SPDLOG_INLINE const filename_t &file_helper::filename() const const filename_t &file_helper::filename() const
{ {
return filename_; return filename_;
} }
@ -154,7 +154,7 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const
// ".mylog" => (".mylog". "") // ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname) std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
{ {
auto ext_index = fname.rfind('.'); auto ext_index = fname.rfind('.');

6
include/spdlog/details/log_msg-inl.h
View File

@ -12,7 +12,7 @@
namespace spdlog { namespace spdlog {
namespace details { 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, 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) spdlog::level lvl, spdlog::string_view_t msg)
: logger_name(a_logger_name) : logger_name(a_logger_name)
, log_level(lvl) , log_level(lvl)
@ -24,12 +24,12 @@ SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::s
, payload(msg) , payload(msg)
{} {}
SPDLOG_INLINE log_msg::log_msg( log_msg::log_msg(
spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t 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)
{} {}
SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t 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)
{} {}

12
include/spdlog/details/log_msg_buffer-inl.h
View File

@ -10,7 +10,7 @@
namespace spdlog { namespace spdlog {
namespace details { 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} : log_msg{orig_msg}
{ {
buffer.append(logger_name.begin(), logger_name.end()); buffer.append(logger_name.begin(), logger_name.end());
@ -18,7 +18,7 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
update_string_views(); 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} : log_msg{other}
{ {
buffer.append(logger_name.begin(), logger_name.end()); buffer.append(logger_name.begin(), logger_name.end());
@ -26,14 +26,14 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
update_string_views(); 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} : log_msg{other}
, buffer{std::move(other.buffer)} , buffer{std::move(other.buffer)}
{ {
update_string_views(); 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); log_msg::operator=(other);
buffer.clear(); buffer.clear();
@ -42,7 +42,7 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot
return *this; 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); log_msg::operator=(other);
buffer = std::move(other.buffer); buffer = std::move(other.buffer);
@ -50,7 +50,7 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other)
return *this; 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()}; logger_name = string_view_t{buffer.data(), logger_name.size()};
payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};

54
include/spdlog/details/os-inl.h
View File

@ -74,7 +74,7 @@ namespace spdlog {
namespace details { namespace details {
namespace os { 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 #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
@ -87,7 +87,7 @@ SPDLOG_INLINE spdlog::log_clock::time_point now() noexcept
return log_clock::now(); return log_clock::now();
#endif #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 #ifdef _WIN32
@ -100,13 +100,13 @@ SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) noexcept
return tm; return tm;
} }
SPDLOG_INLINE std::tm localtime() noexcept std::tm localtime() noexcept
{ {
std::time_t now_t = ::time(nullptr); std::time_t now_t = ::time(nullptr);
return localtime(now_t); 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 #ifdef _WIN32
@ -119,14 +119,14 @@ SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) noexcept
return tm; return tm;
} }
SPDLOG_INLINE std::tm gmtime() noexcept std::tm gmtime() noexcept
{ {
std::time_t now_t = ::time(nullptr); std::time_t now_t = ::time(nullptr);
return gmtime(now_t); return gmtime(now_t);
} }
// fopen_s on non windows for writing // 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 _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES # ifdef SPDLOG_WCHAR_FILENAMES
@ -166,7 +166,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
return *fp == nullptr; 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) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return ::_wremove(filename.c_str()); return ::_wremove(filename.c_str());
@ -175,12 +175,12 @@ SPDLOG_INLINE int remove(const filename_t &filename) noexcept
#endif #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; 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) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
return ::_wrename(filename1.c_str(), filename2.c_str()); return ::_wrename(filename1.c_str(), filename2.c_str());
@ -190,7 +190,7 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
} }
// Return true if path exists (file or directory) // 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 _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES # ifdef SPDLOG_WCHAR_FILENAMES
@ -212,7 +212,7 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) noexcept
#endif #endif
// Return file size according to open FILE* object // Return file size according to open FILE* object
SPDLOG_INLINE size_t filesize(FILE *f) size_t filesize(FILE *f)
{ {
if (f == nullptr) if (f == nullptr)
{ {
@ -266,7 +266,7 @@ SPDLOG_INLINE size_t filesize(FILE *f)
#endif #endif
// Return utc offset in minutes or throw spdlog_ex on failure // 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 #ifdef _WIN32
@ -334,7 +334,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
// Return current thread id as size_t // Return current thread id as size_t
// It exists because the std::this_thread::get_id() is much slower(especially // It exists because the std::this_thread::get_id() is much slower(especially
// under VS 2013) // under VS 2013)
SPDLOG_INLINE size_t _thread_id() noexcept size_t _thread_id() noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId()); return static_cast<size_t>(::GetCurrentThreadId());
@ -383,7 +383,7 @@ SPDLOG_INLINE size_t _thread_id() noexcept
} }
// Return current thread id as size_t (from thread local storage) // Return current thread id as size_t (from thread local storage)
SPDLOG_INLINE size_t thread_id() noexcept size_t thread_id() noexcept
{ {
// cache thread id in tls // cache thread id in tls
static thread_local const size_t tid = _thread_id(); static thread_local const size_t tid = _thread_id();
@ -392,7 +392,7 @@ SPDLOG_INLINE size_t thread_id() noexcept
// This is avoid msvc issue in sleep_for that happens if the clock changes. // This is avoid msvc issue in sleep_for that happens if the clock changes.
// See https://github.com/gabime/spdlog/issues/609 // See https://github.com/gabime/spdlog/issues/609
SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) noexcept void sleep_for_millis(unsigned int milliseconds) noexcept
{ {
#if defined(_WIN32) #if defined(_WIN32)
::Sleep(milliseconds); ::Sleep(milliseconds);
@ -403,20 +403,20 @@ SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) noexcept
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #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; memory_buf_t buf;
wstr_to_utf8buf(filename, buf); wstr_to_utf8buf(filename, buf);
return SPDLOG_BUF_TO_STRING(buf); return SPDLOG_BUF_TO_STRING(buf);
} }
#else #else
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) std::string filename_to_str(const filename_t &filename)
{ {
return filename; return filename;
} }
#endif #endif
SPDLOG_INLINE int pid() noexcept int pid() noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
@ -428,7 +428,7 @@ SPDLOG_INLINE int pid() noexcept
// Determine if the terminal supports colors // Determine if the terminal supports colors
// Based on: https://github.com/agauniyal/rang/ // Based on: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool is_color_terminal() noexcept bool is_color_terminal() noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
return true; return true;
@ -459,7 +459,7 @@ SPDLOG_INLINE bool is_color_terminal() noexcept
// Determine if the terminal attached // Determine if the terminal attached
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool in_terminal(FILE *file) noexcept bool in_terminal(FILE *file) noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
@ -470,7 +470,7 @@ SPDLOG_INLINE bool in_terminal(FILE *file) noexcept
} }
#if defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) #if 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<size_t>((std::numeric_limits<int>::max)()) / 2 - 1) if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
{ {
@ -505,7 +505,7 @@ SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
} }
SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
{ {
if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1) if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
{ {
@ -538,7 +538,7 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
#endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32) #endif // defined(SPDLOG_WCHAR_FILENAMES) && defined(_WIN32)
// return true on success // return true on success
static SPDLOG_INLINE bool mkdir_(const filename_t &path) static bool mkdir_(const filename_t &path)
{ {
#ifdef _WIN32 #ifdef _WIN32
# ifdef SPDLOG_WCHAR_FILENAMES # ifdef SPDLOG_WCHAR_FILENAMES
@ -553,7 +553,7 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path)
// create the given directory - and all directories leading to it // create the given directory - and all directories leading to it
// return true on success or if the directory already exists // return true on success or if the directory already exists
SPDLOG_INLINE bool create_dir(const filename_t &path) bool create_dir(const filename_t &path)
{ {
if (path_exists(path)) if (path_exists(path))
{ {
@ -592,13 +592,13 @@ SPDLOG_INLINE bool create_dir(const filename_t &path)
// "abc/" => "abc" // "abc/" => "abc"
// "abc" => "" // "abc" => ""
// "abc///" => "abc//" // "abc///" => "abc//"
SPDLOG_INLINE 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); auto pos = path.find_last_of(folder_seps_filename);
return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; 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) #if defined(_MSC_VER)
@ -618,7 +618,7 @@ std::string SPDLOG_INLINE getenv(const char *field)
// Do fsync by FILE handlerpointer // Do fsync by FILE handlerpointer
// Return true on success // Return true on success
SPDLOG_INLINE bool fsync(FILE *fp) bool fsync(FILE *fp)
{ {
#ifdef _WIN32 #ifdef _WIN32
return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0; return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0;

2
include/spdlog/details/periodic_worker-inl.h
View File

@ -11,7 +11,7 @@ namespace spdlog {
namespace details { namespace details {
// stop the worker thread and join it // stop the worker thread and join it
SPDLOG_INLINE periodic_worker::~periodic_worker() periodic_worker::~periodic_worker()
{ {
if (worker_thread_.joinable()) if (worker_thread_.joinable())
{ {

52
include/spdlog/details/registry-inl.h
View File

@ -30,7 +30,7 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE registry::registry() registry::registry()
: formatter_(new pattern_formatter()) : formatter_(new pattern_formatter())
{ {
@ -49,15 +49,15 @@ SPDLOG_INLINE registry::registry()
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
} }
SPDLOG_INLINE registry::~registry() = default; registry::~registry() = default;
SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) void registry::register_logger(std::shared_ptr<logger> new_logger)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
register_logger_(std::move(new_logger)); register_logger_(std::move(new_logger));
} }
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) void registry::initialize_logger(std::shared_ptr<logger> new_logger)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone()); new_logger->set_formatter(formatter_->clone());
@ -80,14 +80,14 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logge
} }
} }
SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) std::shared_ptr<logger> registry::get(const std::string &logger_name)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name); auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second; return found == loggers_.end() ? nullptr : found->second;
} }
SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() std::shared_ptr<logger> registry::default_logger()
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_; return default_logger_;
@ -97,14 +97,14 @@ SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
// To be used directly by the spdlog default api (e.g. spdlog::info) // 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(). // 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. // 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(); return default_logger_.get();
} }
// set default logger. // set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // 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<logger> new_default_logger) void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map // remove previous default logger from the map
@ -119,20 +119,20 @@ SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_defa
default_logger_ = std::move(new_default_logger); default_logger_ = std::move(new_default_logger);
} }
SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) void registry::set_tp(std::shared_ptr<thread_pool> tp)
{ {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp); tp_ = std::move(tp);
} }
SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() std::shared_ptr<thread_pool> registry::get_tp()
{ {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
return tp_; return tp_;
} }
// Set global formatter. Each sink in each logger will get a clone of this object // 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> formatter) void registry::set_formatter(std::unique_ptr<formatter> formatter)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter); formatter_ = std::move(formatter);
@ -142,7 +142,7 @@ SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
} }
} }
SPDLOG_INLINE void registry::set_level(level level) void registry::set_level(level level)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -152,7 +152,7 @@ SPDLOG_INLINE void registry::set_level(level level)
global_log_level_ = level; global_log_level_ = level;
} }
SPDLOG_INLINE void registry::flush_on(level level) void registry::flush_on(level level)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -162,7 +162,7 @@ SPDLOG_INLINE void registry::flush_on(level level)
flush_level_ = level; flush_level_ = level;
} }
SPDLOG_INLINE void registry::set_error_handler(err_handler handler) void registry::set_error_handler(err_handler handler)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -172,7 +172,7 @@ SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
err_handler_ = std::move(handler); err_handler_ = std::move(handler);
} }
SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun) void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -181,7 +181,7 @@ SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::share
} }
} }
SPDLOG_INLINE void registry::flush_all() void registry::flush_all()
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -190,7 +190,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<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; auto is_default_logger = default_logger_ && default_logger_->name() == logger_name;
@ -201,7 +201,7 @@ SPDLOG_INLINE void registry::drop(const std::string &logger_name)
} }
} }
SPDLOG_INLINE void registry::drop_all() void registry::drop_all()
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
loggers_.clear(); loggers_.clear();
@ -209,7 +209,7 @@ SPDLOG_INLINE void registry::drop_all()
} }
// clean all resources and threads started by the registry // clean all resources and threads started by the registry
SPDLOG_INLINE void registry::shutdown() void registry::shutdown()
{ {
{ {
std::lock_guard<std::mutex> lock(flusher_mutex_); std::lock_guard<std::mutex> lock(flusher_mutex_);
@ -224,18 +224,18 @@ SPDLOG_INLINE void registry::shutdown()
} }
} }
SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() std::recursive_mutex &registry::tp_mutex()
{ {
return 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<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
automatic_registration_ = automatic_registration; automatic_registration_ = automatic_registration;
} }
SPDLOG_INLINE void registry::set_levels(log_levels levels, level *global_level) void registry::set_levels(log_levels levels, level *global_level)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
log_levels_ = std::move(levels); log_levels_ = std::move(levels);
@ -256,13 +256,13 @@ SPDLOG_INLINE void registry::set_levels(log_levels levels, level *global_level)
} }
} }
SPDLOG_INLINE registry &registry::instance() registry &registry::instance()
{ {
static registry s_instance; static registry s_instance;
return s_instance; return s_instance;
} }
SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger)
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto it = log_levels_.find(new_logger->name()); auto it = log_levels_.find(new_logger->name());
@ -270,7 +270,7 @@ SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new
new_logger->set_level(new_level); new_logger->set_level(new_level);
} }
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()) if (loggers_.find(logger_name) != loggers_.end())
{ {
@ -278,7 +278,7 @@ SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
} }
} }
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) void registry::register_logger_(std::shared_ptr<logger> new_logger)
{ {
auto logger_name = new_logger->name(); auto logger_name = new_logger->name();
throw_if_exists_(logger_name); throw_if_exists_(logger_name);

28
include/spdlog/details/thread_pool-inl.h
View File

@ -13,7 +13,7 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE thread_pool::thread_pool( thread_pool::thread_pool(
size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop) size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
: q_(q_max_items) : q_(q_max_items)
{ {
@ -32,17 +32,17 @@ SPDLOG_INLINE thread_pool::thread_pool(
} }
} }
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start) thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
: thread_pool(q_max_items, threads_n, on_thread_start, [] {}) : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
{} {}
SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
: thread_pool( : thread_pool(
q_max_items, threads_n, [] {}, [] {}) q_max_items, threads_n, [] {}, [] {})
{} {}
// message all threads to terminate gracefully join them // message all threads to terminate gracefully join them
SPDLOG_INLINE thread_pool::~thread_pool() thread_pool::~thread_pool()
{ {
SPDLOG_TRY SPDLOG_TRY
{ {
@ -59,43 +59,43 @@ SPDLOG_INLINE thread_pool::~thread_pool()
SPDLOG_CATCH_STD SPDLOG_CATCH_STD
} }
void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) void 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); async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
post_async_msg_(std::move(async_m), overflow_policy); 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); 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(); return q_.overrun_counter();
} }
void SPDLOG_INLINE thread_pool::reset_overrun_counter() void thread_pool::reset_overrun_counter()
{ {
q_.reset_overrun_counter(); q_.reset_overrun_counter();
} }
size_t SPDLOG_INLINE thread_pool::discard_counter() size_t thread_pool::discard_counter()
{ {
return q_.discard_counter(); return q_.discard_counter();
} }
void SPDLOG_INLINE thread_pool::reset_discard_counter() void thread_pool::reset_discard_counter()
{ {
q_.reset_discard_counter(); q_.reset_discard_counter();
} }
size_t SPDLOG_INLINE thread_pool::queue_size() size_t thread_pool::queue_size()
{ {
return q_.size(); return q_.size();
} }
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) if (overflow_policy == async_overflow_policy::block)
{ {
@ -112,7 +112,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_()) {} while (process_next_msg_()) {}
} }
@ -120,7 +120,7 @@ void SPDLOG_INLINE thread_pool::worker_loop_()
// process next message in the queue // process next message in the queue
// return true if this thread should still be active (while no terminate msg // return true if this thread should still be active (while no terminate msg
// was received) // was received)
bool SPDLOG_INLINE thread_pool::process_next_msg_() bool thread_pool::process_next_msg_()
{ {
async_msg incoming_async_msg; async_msg incoming_async_msg;
q_.dequeue(incoming_async_msg); q_.dequeue(incoming_async_msg);

34
include/spdlog/logger-inl.h
View File

@ -15,7 +15,7 @@
namespace spdlog { namespace spdlog {
// public methods // public methods
SPDLOG_INLINE logger::logger(const logger &other) noexcept logger::logger(const logger &other) noexcept
: name_(other.name_) : name_(other.name_)
, sinks_(other.sinks_) , sinks_(other.sinks_)
, level_(other.level_.load(std::memory_order_relaxed)) , level_(other.level_.load(std::memory_order_relaxed))
@ -23,7 +23,7 @@ SPDLOG_INLINE logger::logger(const logger &other) noexcept
, custom_err_handler_(other.custom_err_handler_) , custom_err_handler_(other.custom_err_handler_)
{} {}
SPDLOG_INLINE logger::logger(logger &&other) noexcept logger::logger(logger &&other) noexcept
: name_(std::move(other.name_)) : name_(std::move(other.name_))
, sinks_(std::move(other.sinks_)) , sinks_(std::move(other.sinks_))
, level_(other.level_.load(std::memory_order_relaxed)) , level_(other.level_.load(std::memory_order_relaxed))
@ -31,24 +31,24 @@ SPDLOG_INLINE logger::logger(logger &&other) noexcept
, custom_err_handler_(std::move(other.custom_err_handler_)) , custom_err_handler_(std::move(other.custom_err_handler_))
{} {}
SPDLOG_INLINE void logger::set_level(level level) void logger::set_level(level level)
{ {
level_.store(level); level_.store(level);
} }
SPDLOG_INLINE level logger::log_level() const level logger::log_level() const
{ {
return static_cast<level>(level_.load(std::memory_order_relaxed)); return static_cast<level>(level_.load(std::memory_order_relaxed));
} }
SPDLOG_INLINE const std::string &logger::name() const const std::string &logger::name() const
{ {
return name_; return name_;
} }
// set formatting for the sinks in this logger. // set formatting for the sinks in this logger.
// each sink will get a separate instance of the formatter object. // each sink will get a separate instance of the formatter object.
SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) void logger::set_formatter(std::unique_ptr<formatter> f)
{ {
for (auto it = sinks_.begin(); it != sinks_.end(); ++it) for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
{ {
@ -65,54 +65,54 @@ SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> 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<pattern_formatter>(std::move(pattern), time_type); auto new_formatter = std::make_unique<pattern_formatter>(std::move(pattern), time_type);
set_formatter(std::move(new_formatter)); set_formatter(std::move(new_formatter));
} }
// flush functions // flush functions
SPDLOG_INLINE void logger::flush() void logger::flush()
{ {
flush_(); flush_();
} }
SPDLOG_INLINE void logger::flush_on(level level) void logger::flush_on(level level)
{ {
flush_level_.store(level); flush_level_.store(level);
} }
SPDLOG_INLINE level logger::flush_level() const level logger::flush_level() const
{ {
return static_cast<level>(flush_level_.load(std::memory_order_relaxed)); return static_cast<level>(flush_level_.load(std::memory_order_relaxed));
} }
// sinks // sinks
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const const std::vector<sink_ptr> &logger::sinks() const
{ {
return sinks_; return sinks_;
} }
SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() std::vector<sink_ptr> &logger::sinks()
{ {
return sinks_; return sinks_;
} }
// error handler // 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); custom_err_handler_ = std::move(handler);
} }
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) std::shared_ptr<logger> logger::clone(std::string logger_name)
{ {
auto cloned = std::make_shared<logger>(*this); auto cloned = std::make_shared<logger>(*this);
cloned->name_ = std::move(logger_name); cloned->name_ = std::move(logger_name);
return cloned; return cloned;
} }
SPDLOG_INLINE void logger::flush_() void logger::flush_()
{ {
for (auto &sink : sinks_) for (auto &sink : sinks_)
{ {
@ -124,13 +124,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); auto flush_level = flush_level_.load(std::memory_order_relaxed);
return (msg.log_level >= flush_level) && (msg.log_level != level::off); return (msg.log_level >= flush_level) && (msg.log_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_) if (custom_err_handler_)
{ {

20
include/spdlog/pattern_formatter-inl.h
View File

@ -1019,7 +1019,7 @@ private:
} // namespace details } // namespace details
SPDLOG_INLINE pattern_formatter::pattern_formatter( pattern_formatter::pattern_formatter(
std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags) std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags)
: pattern_(std::move(pattern)) : pattern_(std::move(pattern))
, eol_(std::move(eol)) , eol_(std::move(eol))
@ -1033,7 +1033,7 @@ SPDLOG_INLINE pattern_formatter::pattern_formatter(
} }
// use by default full formatter for if pattern is not given // 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_("%+") : pattern_("%+")
, eol_(std::move(eol)) , eol_(std::move(eol))
, pattern_time_type_(time_type) , pattern_time_type_(time_type)
@ -1044,7 +1044,7 @@ SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type,
formatters_.push_back(std::make_unique<details::full_formatter>(details::padding_info{})); formatters_.push_back(std::make_unique<details::full_formatter>(details::padding_info{}));
} }
SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const std::unique_ptr<formatter> pattern_formatter::clone() const
{ {
custom_flags cloned_custom_formatters; custom_flags cloned_custom_formatters;
for (auto &it : custom_handlers_) for (auto &it : custom_handlers_)
@ -1060,7 +1060,7 @@ SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
#endif #endif
} }
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)
{ {
if (need_localtime_) if (need_localtime_)
{ {
@ -1080,19 +1080,19 @@ SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory
details::fmt_helper::append_string_view(eol_, dest); 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); pattern_ = std::move(pattern);
need_localtime_ = false; need_localtime_ = false;
compile_pattern_(pattern_); compile_pattern_(pattern_);
} }
SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) void pattern_formatter::need_localtime(bool need)
{ {
need_localtime_ = need; need_localtime_ = need;
} }
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) if (pattern_time_type_ == pattern_time_type::local)
{ {
@ -1102,7 +1102,7 @@ SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg)
} }
template<typename Padder> template<typename Padder>
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 // process custom flags
auto it = custom_handlers_.find(flag); auto it = custom_handlers_.find(flag);
@ -1335,7 +1335,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) // 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) // Advance the given it pass the end of the padding spec found (if any)
// Return padding. // 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::padding_info;
using details::scoped_padder; using details::scoped_padder;
@ -1387,7 +1387,7 @@ SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::stri
return details::padding_info{std::min<size_t>(width, max_width), side, truncate}; return details::padding_info{std::min<size_t>(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(); auto end = pattern.end();
std::unique_ptr<details::aggregate_formatter> user_chars; std::unique_ptr<details::aggregate_formatter> user_chars;

26
include/spdlog/sinks/ansicolor_sink-inl.h
View File

@ -14,7 +14,7 @@ namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode) ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
: target_file_(target_file) : target_file_(target_file)
, mutex_(ConsoleMutex::mutex()) , mutex_(ConsoleMutex::mutex())
, formatter_(std::make_unique<spdlog::pattern_formatter>()) , formatter_(std::make_unique<spdlog::pattern_formatter>())
@ -31,14 +31,14 @@ SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, co
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level color_level, string_view_t color) void ansicolor_sink<ConsoleMutex>::set_color(level color_level, string_view_t color)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
colors_.at(level_to_number(color_level)) = to_string_(color); colors_.at(level_to_number(color_level)) = to_string_(color);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
{ {
// Wrap the originally formatted message in color codes. // Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead. // If color is not supported in the terminal, log as is instead.
@ -66,34 +66,34 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() void ansicolor_sink<ConsoleMutex>::flush()
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_); fflush(target_file_);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() bool ansicolor_sink<ConsoleMutex>::should_color()
{ {
return should_do_colors_; return should_do_colors_;
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{ {
switch (mode) switch (mode)
{ {
@ -112,32 +112,32 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
{ {
fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_); fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end) void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
{ {
fwrite(formatted.data() + start, sizeof(char), end - start, target_file_); fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
{ {
return {sv.data(), sv.size()}; return {sv.data(), sv.size()};
} }
// ansicolor_stdout_sink // ansicolor_stdout_sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode) ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
: ansicolor_sink<ConsoleMutex>(stdout, mode) : ansicolor_sink<ConsoleMutex>(stdout, mode)
{} {}
// ansicolor_stderr_sink // ansicolor_stderr_sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode) ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
: ansicolor_sink<ConsoleMutex>(stderr, mode) : ansicolor_sink<ConsoleMutex>(stderr, mode)
{} {}

16
include/spdlog/sinks/base_sink-inl.h
View File

@ -13,51 +13,51 @@
#include <memory> #include <memory>
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink() spdlog::sinks::base_sink<Mutex>::base_sink()
: formatter_{std::make_unique<spdlog::pattern_formatter>()} : formatter_{std::make_unique<spdlog::pattern_formatter>()}
{} {}
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter) spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter)
: formatter_{std::move(formatter)} : formatter_{std::move(formatter)}
{} {}
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) void spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
{ {
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg); sink_it_(msg);
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() void spdlog::sinks::base_sink<Mutex>::flush()
{ {
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
flush_(); flush_();
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) void spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
{ {
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
set_pattern_(pattern); set_pattern_(pattern);
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {
std::lock_guard<Mutex> lock(mutex_); std::lock_guard<Mutex> lock(mutex_);
set_formatter_(std::move(sink_formatter)); set_formatter_(std::move(sink_formatter));
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) void spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
{ {
set_formatter_(std::make_unique<spdlog::pattern_formatter>(pattern)); set_formatter_(std::make_unique<spdlog::pattern_formatter>(pattern));
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) void spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }

8
include/spdlog/sinks/basic_file_sink-inl.h
View File

@ -14,20 +14,20 @@ namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers) basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers)
: file_helper_{event_handlers} : file_helper_{event_handlers}
{ {
file_helper_.open(filename, truncate); file_helper_.open(filename, truncate);
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const const filename_t &basic_file_sink<Mutex>::filename() const
{ {
return file_helper_.filename(); return file_helper_.filename();
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
{ {
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
@ -35,7 +35,7 @@ SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() void basic_file_sink<Mutex>::flush_()
{ {
file_helper_.flush(); file_helper_.flush();
} }

14
include/spdlog/sinks/rotating_file_sink-inl.h
View File

@ -24,7 +24,7 @@ namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink( rotating_file_sink<Mutex>::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) 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)) : base_filename_(std::move(base_filename))
, max_size_(max_size) , max_size_(max_size)
@ -52,7 +52,7 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
// calc filename according to index and file extension if exists. // calc filename according to index and file extension if exists.
// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt". // e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index) filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index)
{ {
if (index == 0u) if (index == 0u)
{ {
@ -65,14 +65,14 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() filename_t rotating_file_sink<Mutex>::filename()
{ {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return file_helper_.filename(); return file_helper_.filename();
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
{ {
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
@ -95,7 +95,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &m
} }
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_() void rotating_file_sink<Mutex>::flush_()
{ {
file_helper_.flush(); file_helper_.flush();
} }
@ -106,7 +106,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_()
// log.2.txt -> log.3.txt // log.2.txt -> log.3.txt
// log.3.txt -> delete // log.3.txt -> delete
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() void rotating_file_sink<Mutex>::rotate_()
{ {
using details::os::filename_to_str; using details::os::filename_to_str;
using details::os::path_exists; using details::os::path_exists;
@ -141,7 +141,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_()
// delete the target if exists, and rename the src file to target // delete the target if exists, and rename the src file to target
// return true on success, false otherwise. // return true on success, false otherwise.
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename, const filename_t &target_filename) bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename, const filename_t &target_filename)
{ {
// try to delete the target file in case it already exists. // try to delete the target file in case it already exists.
(void)details::os::remove(target_filename); (void)details::os::remove(target_filename);

6
include/spdlog/sinks/sink-inl.h
View File

@ -9,16 +9,16 @@
#include <spdlog/common.h> #include <spdlog/common.h>
SPDLOG_INLINE 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); return msg_level >= level_.load(std::memory_order_relaxed);
} }
SPDLOG_INLINE void spdlog::sinks::sink::set_level(level level) void spdlog::sinks::sink::set_level(level level)
{ {
level_.store(level, std::memory_order_relaxed); level_.store(level, std::memory_order_relaxed);
} }
SPDLOG_INLINE spdlog::level spdlog::sinks::sink::log_level() const { spdlog::level spdlog::sinks::sink::log_level() const {
return static_cast<spdlog::level>(level_.load(std::memory_order_relaxed)); return static_cast<spdlog::level>(level_.load(std::memory_order_relaxed));
} }

8
include/spdlog/sinks/stdout_color_sinks-inl.h
View File

@ -13,25 +13,25 @@
namespace spdlog { namespace spdlog {
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode) std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
{ {
return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode); return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode) std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
{ {
return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode); return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode) std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode)
{ {
return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode); return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode) std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
{ {
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode); return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
} }

22
include/spdlog/sinks/stdout_sinks-inl.h
View File

@ -29,7 +29,7 @@ namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file) stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
: mutex_(ConsoleMutex::mutex()) : mutex_(ConsoleMutex::mutex())
, file_(file) , file_(file)
, formatter_(std::make_unique<spdlog::pattern_formatter>()) , formatter_(std::make_unique<spdlog::pattern_formatter>())
@ -50,7 +50,7 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
{ {
#ifdef _WIN32 #ifdef _WIN32
if (handle_ == INVALID_HANDLE_VALUE) if (handle_ == INVALID_HANDLE_VALUE)
@ -77,21 +77,21 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() void stdout_sink_base<ConsoleMutex>::flush()
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
fflush(file_); fflush(file_);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
@ -99,13 +99,13 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr
// stdout sink // stdout sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink() stdout_sink<ConsoleMutex>::stdout_sink()
: stdout_sink_base<ConsoleMutex>(stdout) : stdout_sink_base<ConsoleMutex>(stdout)
{} {}
// stderr sink // stderr sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink() stderr_sink<ConsoleMutex>::stderr_sink()
: stdout_sink_base<ConsoleMutex>(stderr) : stdout_sink_base<ConsoleMutex>(stderr)
{} {}
@ -113,25 +113,25 @@ SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
// factory methods // factory methods
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
{ {
return Factory::template create<sinks::stdout_sink_mt>(logger_name); return Factory::template create<sinks::stdout_sink_mt>(logger_name);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
{ {
return Factory::template create<sinks::stdout_sink_st>(logger_name); return Factory::template create<sinks::stdout_sink_st>(logger_name);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
{ {
return Factory::template create<sinks::stderr_sink_mt>(logger_name); return Factory::template create<sinks::stderr_sink_mt>(logger_name);
} }
template<typename Factory> template<typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
{ {
return Factory::template create<sinks::stderr_sink_st>(logger_name); return Factory::template create<sinks::stderr_sink_st>(logger_name);
} }

28
include/spdlog/sinks/wincolor_sink-inl.h
View File

@ -16,7 +16,7 @@
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode) wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode)
: out_handle_(out_handle) : out_handle_(out_handle)
, mutex_(ConsoleMutex::mutex()) , mutex_(ConsoleMutex::mutex())
, formatter_(std::make_unique<spdlog::pattern_formatter>()) , formatter_(std::make_unique<spdlog::pattern_formatter>())
@ -35,21 +35,21 @@ SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink() wincolor_sink<ConsoleMutex>::~wincolor_sink()
{ {
this->flush(); this->flush();
} }
// change the color for the given level // change the color for the given level
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level level, std::uint16_t color) void wincolor_sink<ConsoleMutex>::set_color(level level, std::uint16_t color)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
colors_[level_to_number(level)] = color; colors_[level_to_number(level)] = color;
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg) void wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
{ {
if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE)
{ {
@ -79,34 +79,34 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush() void wincolor_sink<ConsoleMutex>::flush()
{ {
// windows console always flushed? // windows console always flushed?
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) void wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) void wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{ {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
set_color_mode_impl(mode); set_color_mode_impl(mode);
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode) void wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode)
{ {
if (mode == color_mode::automatic) if (mode == color_mode::automatic)
{ {
@ -123,7 +123,7 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode m
// set foreground color and return the orig console attributes (for resetting later) // set foreground color and return the orig console attributes (for resetting later)
template<typename ConsoleMutex> template<typename ConsoleMutex>
std::uint16_t SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) std::uint16_t wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs)
{ {
CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info)) if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info))
@ -141,7 +141,7 @@ std::uint16_t SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_foreground_color_(s
// print a range of formatted message to console // print a range of formatted message to console
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end) void wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
{ {
if (end > start) if (end > start)
{ {
@ -152,7 +152,7 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted) void wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted)
{ {
auto size = static_cast<DWORD>(formatted.size()); auto size = static_cast<DWORD>(formatted.size());
DWORD bytes_written = 0; DWORD bytes_written = 0;
@ -162,13 +162,13 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_
// wincolor_stdout_sink // wincolor_stdout_sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode) wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode)
: wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode) : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode)
{} {}
// wincolor_stderr_sink // wincolor_stderr_sink
template<typename ConsoleMutex> template<typename ConsoleMutex>
SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode) wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode)
: wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode)
{} {}
} // namespace sinks } // namespace sinks

38
include/spdlog/spdlog-inl.h
View File

@ -12,97 +12,97 @@
namespace spdlog { namespace spdlog {
SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger) void initialize_logger(std::shared_ptr<logger> logger)
{ {
details::registry::instance().initialize_logger(std::move(logger)); details::registry::instance().initialize_logger(std::move(logger));
} }
SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name) std::shared_ptr<logger> get(const std::string &name)
{ {
return details::registry::instance().get(name); return details::registry::instance().get(name);
} }
SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> formatter) void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
{ {
details::registry::instance().set_formatter(std::move(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<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type))); set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
} }
SPDLOG_INLINE level get_level() level get_level()
{ {
return default_logger_raw()->log_level(); return default_logger_raw()->log_level();
} }
SPDLOG_INLINE bool should_log(level level) bool should_log(level level)
{ {
return default_logger_raw()->should_log(level); return default_logger_raw()->should_log(level);
} }
SPDLOG_INLINE void set_level(level level) void set_level(level level)
{ {
details::registry::instance().set_level(level); details::registry::instance().set_level(level);
} }
SPDLOG_INLINE void flush_on(level level) void flush_on(level level)
{ {
details::registry::instance().flush_on(level); details::registry::instance().flush_on(level);
} }
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); details::registry::instance().set_error_handler(handler);
} }
SPDLOG_INLINE void register_logger(std::shared_ptr<logger> logger) void register_logger(std::shared_ptr<logger> logger)
{ {
details::registry::instance().register_logger(std::move(logger)); details::registry::instance().register_logger(std::move(logger));
} }
SPDLOG_INLINE void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun) void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun)
{ {
details::registry::instance().apply_all(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); details::registry::instance().drop(name);
} }
SPDLOG_INLINE void drop_all() void drop_all()
{ {
details::registry::instance().drop_all(); details::registry::instance().drop_all();
} }
SPDLOG_INLINE void shutdown() void shutdown()
{ {
details::registry::instance().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); details::registry::instance().set_automatic_registration(automatic_registration);
} }
SPDLOG_INLINE std::shared_ptr<spdlog::logger> default_logger() std::shared_ptr<spdlog::logger> default_logger()
{ {
return details::registry::instance().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(); return details::registry::instance().get_default_raw();
} }
SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) void set_default_logger(std::shared_ptr<spdlog::logger> default_logger)
{ {
details::registry::instance().set_default_logger(std::move(default_logger)); details::registry::instance().set_default_logger(std::move(default_logger));
} }
SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr<logger> logger) void apply_logger_env_levels(std::shared_ptr<logger> logger)
{ {
details::registry::instance().apply_logger_env_levels(std::move(logger)); details::registry::instance().apply_logger_env_levels(std::move(logger));
} }