Removed SPDLOG_INLINE macro

include/spdlog/common.h

@@ -22,19 +22,10 @@
 #endif
 #else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB)
 #define SPDLOG_API
-#define SPDLOG_INLINE
 #endif
 
 #include <spdlog/fmt/fmt.h>
 
-#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)

src/async_logger.cpp

@@ -8,18 +8,18 @@
 #include <memory>
 #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)
     : 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)
     : 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::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);
     cloned->name_ = std::move(new_name);

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)));
 }

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<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('.');
 

src/details/helpers.cpp

@@ -73,7 +73,7 @@ inline std::unordered_map<std::string, std::string> 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;

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)
 {}
 

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()};

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<size_t>(::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<size_t>((std::numeric_limits<int>::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)

src/details/periodic_worker.cpp

@@ -6,7 +6,7 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+periodic_worker::periodic_worker(const std::function<void()> &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<void()> &call
 }
 
 // stop the worker thread and join it
-SPDLOG_INLINE periodic_worker::~periodic_worker()
+periodic_worker::~periodic_worker()
 {
     if (worker_thread_.joinable())
     {

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<logger> new_logger)
+void registry::register_logger(std::shared_ptr<logger> new_logger)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     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_);
     new_logger->set_formatter(formatter_->clone());
@@ -71,14 +71,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_);
     auto found = loggers_.find(logger_name);
     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_);
     return default_logger_;
@@ -88,14 +88,14 @@ SPDLOG_INLINE std::shared_ptr<logger> 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<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_);
     // remove previous default logger from the map
@@ -110,20 +110,20 @@ SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_defa
     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_);
     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_);
     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> formatter)
+void registry::set_formatter(std::unique_ptr<formatter> formatter)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     formatter_ = std::move(formatter);
@@ -133,7 +133,7 @@ SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
     }
 }
 
-SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+void registry::set_level(level::level_enum log_level)
 {
     std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> lock(flusher_mutex_);
     auto clbk = [this]() { this->flush_all(); };
     periodic_flusher_ = std::make_unique<periodic_worker>(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<std::mutex> 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<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_);
     for (auto &l : loggers_)
@@ -179,7 +179,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_);
     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<std::mutex> 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<std::mutex> 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<std::mutex> lock(flusher_mutex_);
@@ -221,18 +221,18 @@ SPDLOG_INLINE void registry::shutdown()
     }
 }
 
-SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+std::recursive_mutex &registry::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_);
     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<std::mutex> 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 &registry::instance()
+registry &registry::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<logger> new_logger)
+void registry::register_logger_(std::shared_ptr<logger> new_logger)
 {
     auto logger_name = new_logger->name();
     throw_if_exists_(logger_name);

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<void()> on_thread_start)
+thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> 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));

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::level_enum>(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<formatter> f)
+void logger::set_formatter(std::unique_ptr<formatter> f)
 {
     for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
     {
@@ -89,54 +89,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);
     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<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
 }
 
 // sinks
-SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const
+const std::vector<sink_ptr> &logger::sinks() const
 {
     return sinks_;
 }
 
-SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
+std::vector<sink_ptr> &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> logger::clone(std::string logger_name)
+std::shared_ptr<logger> logger::clone(std::string logger_name)
 {
     auto cloned = std::make_shared<logger>(*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_)
     {

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::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;
     for (auto &it : custom_handlers_)
@@ -1020,7 +1019,7 @@ SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
     return std::make_unique<pattern_formatter>(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<std::chrono::seconds>(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<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
     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<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();
     std::unique_ptr<details::aggregate_formatter> user_chars;

src/sinks/ansicolor_sink.cpp

@@ -12,7 +12,7 @@ namespace spdlog {
 namespace sinks {
 
 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)
     , mutex_(ConsoleMutex::mutex())
     , formatter_(std::make_unique<spdlog::pattern_formatter>())
@@ -29,14 +29,14 @@ SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, co
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
+void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
 {
     std::lock_guard<mutex_t> lock(mutex_);
     colors_[color_level] = to_string_(color);
 }
 
 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.
     // If color is not supported in the terminal, log as is instead.
@@ -64,34 +64,34 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush()
+void ansicolor_sink<ConsoleMutex>::flush()
 {
     std::lock_guard<mutex_t> lock(mutex_);
     fflush(target_file_);
 }
 
 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_);
     formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
 }
 
 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_);
     formatter_ = std::move(sink_formatter);
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color()
+bool ansicolor_sink<ConsoleMutex>::should_color()
 {
     return should_do_colors_;
 }
 
 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)
     {
@@ -108,32 +108,32 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
 }
 
 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_);
 }
 
 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_);
 }
 
 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 std::string(sv.data(), sv.size());
 }
 
 // ansicolor_stdout_sink
 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_stderr_sink
 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)
 {}
 

src/sinks/base_sink.cpp

@@ -9,51 +9,51 @@
 #include <memory>
 
 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>()}
 {}
 
 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)}
 {}
 
 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_);
     sink_it_(msg);
 }
 
 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_);
     flush_();
 }
 
 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_);
     set_pattern_(pattern);
 }
 
 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_);
     set_formatter_(std::move(sink_formatter));
 }
 
 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));
 }
 
 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);
 }

src/sinks/basic_file_sink.cpp

@@ -9,19 +9,19 @@ namespace spdlog {
 namespace sinks {
 
 template<typename Mutex>
-SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate)
+basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate)
 {
     file_helper_.open(filename, truncate);
 }
 
 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();
 }
 
 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;
     base_sink<Mutex>::formatter_->format(msg, formatted);
@@ -29,7 +29,7 @@ SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
 }
 
 template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::flush_()
+void basic_file_sink<Mutex>::flush_()
 {
     file_helper_.flush();
 }

src/sinks/rotating_file_sink.cpp

@@ -19,8 +19,7 @@ namespace spdlog {
 namespace sinks {
 
 template<typename Mutex>
-SPDLOG_INLINE 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)
+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)
     : base_filename_(std::move(base_filename))
     , max_size_(max_size)
     , max_files_(max_files)
@@ -36,7 +35,7 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::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<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)
     {
@@ -49,14 +48,14 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename
 }
 
 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_);
     return file_helper_.filename();
 }
 
 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;
     base_sink<Mutex>::formatter_->format(msg, formatted);
@@ -70,7 +69,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &m
 }
 
 template<typename Mutex>
-SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_()
+void rotating_file_sink<Mutex>::flush_()
 {
     file_helper_.flush();
 }
@@ -81,7 +80,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_()
 // log.2.txt -> log.3.txt
 // log.3.txt -> delete
 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::path_exists;
@@ -115,7 +114,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_()
 // delete the target if exists, and rename the src file  to target
 // return true on success, false otherwise.
 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.
     (void)details::os::remove(target_filename);

src/sinks/sink.cpp

@@ -4,17 +4,17 @@
 #include <spdlog/sinks/sink.h>
 #include <spdlog/common.h>
 
-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<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
 }

src/sinks/stdout_color_sinks.cpp

@@ -10,25 +10,25 @@
 namespace spdlog {
 
 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);
 }
 
 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);
 }
 
 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);
 }
 
 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);
 }

src/sinks/stdout_sinks.cpp

@@ -15,14 +15,14 @@ namespace spdlog {
 namespace sinks {
 
 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())
     , file_(file)
     , formatter_(std::make_unique<spdlog::pattern_formatter>())
 {}
 
 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)
 {
     std::lock_guard<mutex_t> lock(mutex_);
     memory_buf_t formatted;
@@ -32,21 +32,21 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush()
+void stdout_sink_base<ConsoleMutex>::flush()
 {
     std::lock_guard<mutex_t> lock(mutex_);
     fflush(file_);
 }
 
 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_);
     formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
 }
 
 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_);
     formatter_ = std::move(sink_formatter);
@@ -54,13 +54,13 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr
 
 // stdout sink
 template<typename ConsoleMutex>
-SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
+stdout_sink<ConsoleMutex>::stdout_sink()
     : stdout_sink_base<ConsoleMutex>(stdout)
 {}
 
 // stderr sink
 template<typename ConsoleMutex>
-SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
+stderr_sink<ConsoleMutex>::stderr_sink()
     : stdout_sink_base<ConsoleMutex>(stderr)
 {}
 
@@ -68,25 +68,25 @@ SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
 
 // factory methods
 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);
 }
 
 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);
 }
 
 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);
 }
 
 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);
 }

src/sinks/wincolor_sink.cpp

@@ -10,7 +10,7 @@ namespace spdlog {
 namespace sinks {
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(HANDLE out_handle, color_mode mode)
+wincolor_sink<ConsoleMutex>::wincolor_sink(HANDLE out_handle, color_mode mode)
     : out_handle_(out_handle)
     , mutex_(ConsoleMutex::mutex())
     , formatter_(std::make_unique<spdlog::pattern_formatter>())
@@ -31,21 +31,21 @@ SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(HANDLE out_handle, colo
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink()
+wincolor_sink<ConsoleMutex>::~wincolor_sink()
 {
     this->flush();
 }
 
 // change the color for the given level
 template<typename ConsoleMutex>
-void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, WORD color)
+void wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, WORD color)
 {
     std::lock_guard<mutex_t> lock(mutex_);
     colors_[level] = color;
 }
 
 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)
 {
     std::lock_guard<mutex_t> lock(mutex_);
     msg.color_range_start = 0;
@@ -76,27 +76,27 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
 }
 
 template<typename ConsoleMutex>
-void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush()
+void wincolor_sink<ConsoleMutex>::flush()
 {
     // windows console always flushed?
 }
 
 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_);
     formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
 }
 
 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_);
     formatter_ = std::move(sink_formatter);
 }
 
 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)
 {
     switch (mode)
     {
@@ -114,7 +114,7 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
 
 // set foreground color and return the orig console attributes (for resetting later)
 template<typename ConsoleMutex>
-WORD SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_foreground_color_(WORD attribs)
+WORD wincolor_sink<ConsoleMutex>::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<ConsoleMutex>::set_foreground_color_(WORD attri
 
 // print a range of formatted message to console
 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)
 {
     auto size = static_cast<DWORD>(end - start);
     ::WriteConsoleA(out_handle_, formatted.data() + start, size, nullptr, nullptr);
 }
 
 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)
 {
     if (out_handle_ == nullptr) // no console and no file redirect
     {
@@ -162,13 +162,13 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_
 
 // wincolor_stdout_sink
 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_stderr_sink
 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)
 {}
 

src/spdlog.cpp

@@ -7,87 +7,87 @@
 
 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));
 }
 
-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);
 }
 
-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));
 }
 
-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)));
 }
 
-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> logger)
+void register_logger(std::shared_ptr<logger> 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);
 }
 
-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<spdlog::logger> default_logger()
+std::shared_ptr<spdlog::logger> 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<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));
 }