move underscores to the end of private members

include/spdlog/details/async_logger_impl.h

@@ -18,8 +18,8 @@ template<class It>
 inline spdlog::async_logger::async_logger(const std::string &logger_name, const It &begin, const It &end,
     std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
     : logger(logger_name, begin, end)
-    , _thread_pool(tp)
-    , _overflow_policy(overflow_policy)
+    , thread_pool_(tp)
+    , overflow_policy_(overflow_policy)
 {
 }
 
@@ -36,14 +36,14 @@ inline spdlog::async_logger::async_logger(
 }
 
 // send the log message to the thread pool
-inline void spdlog::async_logger::_sink_it(details::log_msg &msg)
+inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
 {
 #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
     _incr_msg_counter(msg);
 #endif
-    if (auto pool_ptr = _thread_pool.lock())
+    if (auto pool_ptr = thread_pool_.lock())
     {
-        pool_ptr->post_log(shared_from_this(), std::move(msg), _overflow_policy);
+        pool_ptr->post_log(shared_from_this(), std::move(msg), overflow_policy_);
     }
     else
     {
@@ -52,11 +52,11 @@ inline void spdlog::async_logger::_sink_it(details::log_msg &msg)
 }
 
 // send flush request to the thread pool
-inline void spdlog::async_logger::_flush()
+inline void spdlog::async_logger::flush_()
 {
-    if (auto pool_ptr = _thread_pool.lock())
+    if (auto pool_ptr = thread_pool_.lock())
     {
-        pool_ptr->post_flush(shared_from_this(), _overflow_policy);
+        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
     }
     else
     {
@@ -67,12 +67,12 @@ inline void spdlog::async_logger::_flush()
 //
 // backend functions - called from the thread pool to do the actual job
 //
-inline void spdlog::async_logger::_backend_log(details::log_msg &incoming_log_msg)
+inline void spdlog::async_logger::backend_log_(details::log_msg &incoming_log_msg)
 {
     try
     {
-        _formatter->format(incoming_log_msg);
-        for (auto &s : _sinks)
+        formatter_->format(incoming_log_msg);
+        for (auto &s : sinks_)
         {
             if (s->should_log(incoming_log_msg.level))
             {
@@ -82,17 +82,17 @@ inline void spdlog::async_logger::_backend_log(details::log_msg &incoming_log_ms
     }
     SPDLOG_CATCH_AND_HANDLE
 
-    if (_should_flush(incoming_log_msg))
+    if (should_flush_(incoming_log_msg))
     {
-        _backend_flush();
+        backend_flush_();
     }
 }
 
-inline void spdlog::async_logger::_backend_flush()
+inline void spdlog::async_logger::backend_flush_()
 {
     try
     {
-        for (auto &sink : _sinks)
+        for (auto &sink : sinks_)
         {
             sink->flush();
         }

include/spdlog/details/logger_impl.h

@@ -12,15 +12,15 @@
 // all other ctors will call this one
 template<class It>
 inline spdlog::logger::logger(std::string logger_name, const It &begin, const It &end)
-    : _name(std::move(logger_name))
-    , _sinks(begin, end)
-    , _formatter(std::make_shared<pattern_formatter>("%+"))
-    , _level(level::info)
-    , _flush_level(level::off)
-    , _last_err_time(0)
-    , _msg_counter(1) // message counter will start from 1. 0-message id will be reserved for controll messages
+    : name_(std::move(logger_name))
+    , sinks_(begin, end)
+    , formatter_(std::make_shared<pattern_formatter>("%+"))
+    , level_(level::info)
+    , flush_level_(level::off)
+    , last_err_time_(0)
+    , msg_counter_(1) // message counter will start from 1. 0-message id will be reserved for controll messages
 {
-    _err_handler = [this](const std::string &msg) { this->_default_err_handler(msg); };
+    err_handler_ = [this](const std::string &msg) { this->default_err_handler_(msg); };
 }
 
 // ctor with sinks as init list
@@ -39,12 +39,12 @@ inline spdlog::logger::~logger() = default;
 
 inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
 {
-    _formatter = std::move(msg_formatter);
+    formatter_ = std::move(msg_formatter);
 }
 
 inline void spdlog::logger::set_pattern(const std::string &pattern, pattern_time_type pattern_time)
 {
-    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
+    formatter_ = std::make_shared<pattern_formatter>(pattern, pattern_time);
 }
 
 template<typename... Args>
@@ -57,14 +57,14 @@ inline void spdlog::logger::log(level::level_enum lvl, const char *fmt, const Ar
 
     try
     {
-        details::log_msg log_msg(&_name, lvl);
+        details::log_msg log_msg(&name_, lvl);
 
 #if defined(SPDLOG_FMT_PRINTF)
         fmt::printf(log_msg.raw, fmt, args...);
 #else
         log_msg.raw.write(fmt, args...);
 #endif
-        _sink_it(log_msg);
+        sink_it_(log_msg);
     }
     SPDLOG_CATCH_AND_HANDLE
 }
@@ -78,9 +78,9 @@ inline void spdlog::logger::log(level::level_enum lvl, const char *msg)
     }
     try
     {
-        details::log_msg log_msg(&_name, lvl);
+        details::log_msg log_msg(&name_, lvl);
         log_msg.raw << msg;
-        _sink_it(log_msg);
+        sink_it_(log_msg);
     }
     SPDLOG_CATCH_AND_HANDLE
 }
@@ -94,9 +94,9 @@ inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
     }
     try
     {
-        details::log_msg log_msg(&_name, lvl);
+        details::log_msg log_msg(&name_, lvl);
         log_msg.raw << msg;
-        _sink_it(log_msg);
+        sink_it_(log_msg);
     }
     SPDLOG_CATCH_AND_HANDLE
 }
@@ -237,64 +237,64 @@ inline void spdlog::logger::critical(const wchar_t *fmt, const Args &... args)
 //
 inline const std::string &spdlog::logger::name() const
 {
-    return _name;
+    return name_;
 }
 
 inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
 {
-    _level.store(log_level);
+    level_.store(log_level);
 }
 
 inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
 {
-    _err_handler = std::move(err_handler);
+    err_handler_ = std::move(err_handler);
 }
 
 inline spdlog::log_err_handler spdlog::logger::error_handler()
 {
-    return _err_handler;
+    return err_handler_;
 }
 
 inline void spdlog::logger::flush()
 {
     try
     {
-        _flush();
+        flush_();
     }
     SPDLOG_CATCH_AND_HANDLE
 }
 
 inline void spdlog::logger::flush_on(level::level_enum log_level)
 {
-    _flush_level.store(log_level);
+    flush_level_.store(log_level);
 }
 
-inline bool spdlog::logger::_should_flush(const details::log_msg &msg)
+inline bool spdlog::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.level >= flush_level) && (msg.level != level::off);
 }
 
 inline spdlog::level::level_enum spdlog::logger::level() const
 {
-    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
+    return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
 }
 
 inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
 {
-    return msg_level >= _level.load(std::memory_order_relaxed);
+    return msg_level >= level_.load(std::memory_order_relaxed);
 }
 
 //
 // protected virtual called at end of each user log call (if enabled) by the line_logger
 //
-inline void spdlog::logger::_sink_it(details::log_msg &msg)
+inline void spdlog::logger::sink_it_(details::log_msg &msg)
 {
 #if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-    _incr_msg_counter(msg);
+    incr_msg_counter_(msg);
 #endif
-    _formatter->format(msg);
-    for (auto &sink : _sinks)
+    formatter_->format(msg);
+    for (auto &sink : sinks_)
     {
         if (sink->should_log(msg.level))
         {
@@ -302,40 +302,40 @@ inline void spdlog::logger::_sink_it(details::log_msg &msg)
         }
     }
 
-    if (_should_flush(msg))
+    if (should_flush_(msg))
     {
         flush();
     }
 }
 
-inline void spdlog::logger::_flush()
+inline void spdlog::logger::flush_()
 {
-    for (auto &sink : _sinks)
+    for (auto &sink : sinks_)
     {
         sink->flush();
     }
 }
 
-inline void spdlog::logger::_default_err_handler(const std::string &msg)
+inline void spdlog::logger::default_err_handler_(const std::string &msg)
 {
     auto now = time(nullptr);
-    if (now - _last_err_time < 60)
+    if (now - last_err_time_ < 60)
     {
         return;
     }
-    _last_err_time = now;
+    last_err_time_ = now;
     auto tm_time = details::os::localtime(now);
     char date_buf[100];
     std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
     fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
 }
 
-inline void spdlog::logger::_incr_msg_counter(details::log_msg &msg)
+inline void spdlog::logger::incr_msg_counter_(details::log_msg &msg)
 {
-    msg.msg_id = _msg_counter.fetch_add(1, std::memory_order_relaxed);
+    msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
 }
 
 inline const std::vector<spdlog::sink_ptr> &spdlog::logger::sinks() const
 {
-    return _sinks;
+    return sinks_;
 }

include/spdlog/details/pattern_formatter_impl.h

@@ -335,19 +335,19 @@ public:
     }
 
 private:
-    log_clock::time_point _last_update{std::chrono::seconds(0)};
-    int _offset_minutes{0};
-    std::mutex _mutex;
+    log_clock::time_point last_update_{std::chrono::seconds(0)};
+    int offset_minutes_{0};
+    std::mutex mutex_;
 
     int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
     {
-        std::lock_guard<std::mutex> l(_mutex);
-        if (msg.time - _last_update >= cache_refresh)
+        std::lock_guard<std::mutex> l(mutex_);
+        if (msg.time - last_update_ >= cache_refresh)
         {
-            _offset_minutes = os::utc_minutes_offset(tm_time);
-            _last_update = msg.time;
+            offset_minutes_ = os::utc_minutes_offset(tm_time);
+            last_update_ = msg.time;
         }
-        return _offset_minutes;
+        return offset_minutes_;
     }
 };
 
@@ -390,16 +390,16 @@ class ch_formatter SPDLOG_FINAL : public flag_formatter
 {
 public:
     explicit ch_formatter(char ch)
-        : _ch(ch)
+        : ch_(ch)
     {
     }
     void format(details::log_msg &msg, const std::tm &) override
     {
-        msg.formatted << _ch;
+        msg.formatted << ch_;
     }
 
 private:
-    char _ch;
+    char ch_;
 };
 
 // aggregate user chars to display as is
@@ -410,15 +410,15 @@ public:
 
     void add_ch(char ch)
     {
-        _str += ch;
+        str_ += ch;
     }
     void format(details::log_msg &msg, const std::tm &) override
     {
-        msg.formatted << _str;
+        msg.formatted << str_;
     }
 
 private:
-    std::string _str;
+    std::string str_;
 };
 
 // mark the color range. expect it to be in the form of "%^colored text%$"
@@ -493,8 +493,8 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
 // pattern_formatter inline impl
 ///////////////////////////////////////////////////////////////////////////////
 inline spdlog::pattern_formatter::pattern_formatter(const std::string &pattern, pattern_time_type pattern_time, std::string eol)
-    : _eol(std::move(eol))
-    , _pattern_time(pattern_time)
+    : eol_(std::move(eol))
+    , pattern_time_(pattern_time)
 {
     compile_pattern(pattern);
 }
@@ -509,7 +509,7 @@ inline void spdlog::pattern_formatter::compile_pattern(const std::string &patter
         {
             if (user_chars) // append user chars found so far
             {
-                _formatters.push_back(std::move(user_chars));
+                formatters_.push_back(std::move(user_chars));
             }
             // if(
             if (++it != end)
@@ -532,7 +532,7 @@ inline void spdlog::pattern_formatter::compile_pattern(const std::string &patter
     }
     if (user_chars) // append raw chars found so far
     {
-        _formatters.push_back(std::move(user_chars));
+        formatters_.push_back(std::move(user_chars));
     }
 }
 inline void spdlog::pattern_formatter::handle_flag(char flag)
@@ -541,149 +541,149 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
     {
     // logger name
     case 'n':
-        _formatters.emplace_back(new details::name_formatter());
+        formatters_.emplace_back(new details::name_formatter());
         break;
 
     case 'l':
-        _formatters.emplace_back(new details::level_formatter());
+        formatters_.emplace_back(new details::level_formatter());
         break;
 
     case 'L':
-        _formatters.emplace_back(new details::short_level_formatter());
+        formatters_.emplace_back(new details::short_level_formatter());
         break;
 
     case ('t'):
-        _formatters.emplace_back(new details::t_formatter());
+        formatters_.emplace_back(new details::t_formatter());
         break;
 
     case ('v'):
-        _formatters.emplace_back(new details::v_formatter());
+        formatters_.emplace_back(new details::v_formatter());
         break;
 
     case ('a'):
-        _formatters.emplace_back(new details::a_formatter());
+        formatters_.emplace_back(new details::a_formatter());
         break;
 
     case ('A'):
-        _formatters.emplace_back(new details::A_formatter());
+        formatters_.emplace_back(new details::A_formatter());
         break;
 
     case ('b'):
     case ('h'):
-        _formatters.emplace_back(new details::b_formatter());
+        formatters_.emplace_back(new details::b_formatter());
         break;
 
     case ('B'):
-        _formatters.emplace_back(new details::B_formatter());
+        formatters_.emplace_back(new details::B_formatter());
         break;
     case ('c'):
-        _formatters.emplace_back(new details::c_formatter());
+        formatters_.emplace_back(new details::c_formatter());
         break;
 
     case ('C'):
-        _formatters.emplace_back(new details::C_formatter());
+        formatters_.emplace_back(new details::C_formatter());
         break;
 
     case ('Y'):
-        _formatters.emplace_back(new details::Y_formatter());
+        formatters_.emplace_back(new details::Y_formatter());
         break;
 
     case ('D'):
     case ('x'):
 
-        _formatters.emplace_back(new details::D_formatter());
+        formatters_.emplace_back(new details::D_formatter());
         break;
 
     case ('m'):
-        _formatters.emplace_back(new details::m_formatter());
+        formatters_.emplace_back(new details::m_formatter());
         break;
 
     case ('d'):
-        _formatters.emplace_back(new details::d_formatter());
+        formatters_.emplace_back(new details::d_formatter());
         break;
 
     case ('H'):
-        _formatters.emplace_back(new details::H_formatter());
+        formatters_.emplace_back(new details::H_formatter());
         break;
 
     case ('I'):
-        _formatters.emplace_back(new details::I_formatter());
+        formatters_.emplace_back(new details::I_formatter());
         break;
 
     case ('M'):
-        _formatters.emplace_back(new details::M_formatter());
+        formatters_.emplace_back(new details::M_formatter());
         break;
 
     case ('S'):
-        _formatters.emplace_back(new details::S_formatter());
+        formatters_.emplace_back(new details::S_formatter());
         break;
 
     case ('e'):
-        _formatters.emplace_back(new details::e_formatter());
+        formatters_.emplace_back(new details::e_formatter());
         break;
 
     case ('f'):
-        _formatters.emplace_back(new details::f_formatter());
+        formatters_.emplace_back(new details::f_formatter());
         break;
     case ('F'):
-        _formatters.emplace_back(new details::F_formatter());
+        formatters_.emplace_back(new details::F_formatter());
         break;
 
     case ('E'):
-        _formatters.emplace_back(new details::E_formatter());
+        formatters_.emplace_back(new details::E_formatter());
         break;
 
     case ('p'):
-        _formatters.emplace_back(new details::p_formatter());
+        formatters_.emplace_back(new details::p_formatter());
         break;
 
     case ('r'):
-        _formatters.emplace_back(new details::r_formatter());
+        formatters_.emplace_back(new details::r_formatter());
         break;
 
     case ('R'):
-        _formatters.emplace_back(new details::R_formatter());
+        formatters_.emplace_back(new details::R_formatter());
         break;
 
     case ('T'):
     case ('X'):
-        _formatters.emplace_back(new details::T_formatter());
+        formatters_.emplace_back(new details::T_formatter());
         break;
 
     case ('z'):
-        _formatters.emplace_back(new details::z_formatter());
+        formatters_.emplace_back(new details::z_formatter());
         break;
 
     case ('+'):
-        _formatters.emplace_back(new details::full_formatter());
+        formatters_.emplace_back(new details::full_formatter());
         break;
 
     case ('P'):
-        _formatters.emplace_back(new details::pid_formatter());
+        formatters_.emplace_back(new details::pid_formatter());
         break;
 
     case ('i'):
-        _formatters.emplace_back(new details::i_formatter());
+        formatters_.emplace_back(new details::i_formatter());
         break;
 
     case ('^'):
-        _formatters.emplace_back(new details::color_start_formatter());
+        formatters_.emplace_back(new details::color_start_formatter());
         break;
 
     case ('$'):
-        _formatters.emplace_back(new details::color_stop_formatter());
+        formatters_.emplace_back(new details::color_stop_formatter());
         break;
 
     default: // Unknown flag appears as is
-        _formatters.emplace_back(new details::ch_formatter('%'));
-        _formatters.emplace_back(new details::ch_formatter(flag));
+        formatters_.emplace_back(new details::ch_formatter('%'));
+        formatters_.emplace_back(new details::ch_formatter(flag));
         break;
     }
 }
 
 inline std::tm spdlog::pattern_formatter::get_time(details::log_msg &msg)
 {
-    if (_pattern_time == pattern_time_type::local)
+    if (pattern_time_ == pattern_time_type::local)
     {
         return details::os::localtime(log_clock::to_time_t(msg.time));
     }
@@ -698,10 +698,10 @@ inline void spdlog::pattern_formatter::format(details::log_msg &msg)
 #else
     std::tm tm_time;
 #endif
-    for (auto &f : _formatters)
+    for (auto &f : formatters_)
     {
         f->format(msg, tm_time);
     }
     // write eol
-    msg.formatted << _eol;
+    msg.formatted << eol_;
 }

include/spdlog/details/thread_pool.h

@@ -170,7 +170,7 @@ private:
         {
         case async_msg_type::flush:
         {
-            incoming_async_msg.worker_ptr->_backend_flush();
+            incoming_async_msg.worker_ptr->backend_flush_();
             return true;
         }
 
@@ -183,7 +183,7 @@ private:
         {
             log_msg msg;
             incoming_async_msg.to_log_msg(std::move(msg));
-            incoming_async_msg.worker_ptr->_backend_log(msg);
+            incoming_async_msg.worker_ptr->backend_log_(msg);
             return true;
         }
         }