Merge pull request #647 from DanielChabrowski/clang-tidy

Applied some of clang-tidy fixes

include/spdlog/async_logger.h

@@ -31,7 +31,7 @@ namespace details
 class async_log_helper;
 }
 
-class async_logger SPDLOG_FINAL :public logger
+class async_logger SPDLOG_FINAL : public logger
 {
 public:
     template<class It>
@@ -39,12 +39,12 @@ public:
                  const It& begin,
                  const It& end,
                  size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
+                 const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
                  const std::function<void()>& worker_warmup_cb = nullptr,
                  const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
                  const std::function<void()>& worker_teardown_cb = nullptr);
 
-    async_logger(const std::string& logger_name,
+    async_logger(const std::string& name,
                  sinks_init_list sinks,
                  size_t queue_size,
                  const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
@@ -52,10 +52,10 @@ public:
                  const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
                  const std::function<void()>& worker_teardown_cb = nullptr);
 
-    async_logger(const std::string& logger_name,
+    async_logger(const std::string& name,
                  sink_ptr single_sink,
                  size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
+                 const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
                  const std::function<void()>& worker_warmup_cb = nullptr,
                  const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
                  const std::function<void()>& worker_teardown_cb = nullptr);
@@ -65,8 +65,8 @@ public:
     void flush() override;
 
     // Error handler
-    virtual void set_error_handler(log_err_handler) override;
-    virtual log_err_handler error_handler() override;
+    void set_error_handler(log_err_handler) override;
+    log_err_handler error_handler() override;
 
 protected:
     void _sink_it(details::log_msg& msg) override;
@@ -78,5 +78,4 @@ private:
 };
 }
 
-
 #include "details/async_logger_impl.h"

include/spdlog/common.h

@@ -75,7 +75,7 @@ using log_err_handler = std::function<void(const std::string &err_msg)>;
 //Log level enum
 namespace level
 {
-typedef enum
+enum level_enum
 {
     trace = 0,
     debug = 1,
@@ -84,10 +84,10 @@ typedef enum
     err = 4,
     critical = 5,
     off = 6
-} level_enum;
+};
 
 #if !defined(SPDLOG_LEVEL_NAMES)
-#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info",  "warning", "error", "critical", "off" }
+#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" }
 #endif
 static const char* level_names[] SPDLOG_LEVEL_NAMES;
 
@@ -106,7 +106,6 @@ using level_hasher = std::hash<int>;
 
 } //level
 
-
 //
 // Async overflow policy - block by default.
 //
@@ -136,22 +135,24 @@ namespace os
 std::string errno_str(int err_num);
 }
 }
-class spdlog_ex: public std::exception
+class spdlog_ex : public std::exception
 {
 public:
-    spdlog_ex(const std::string& msg):_msg(msg)
+    explicit spdlog_ex(std::string msg) : _msg(std::move(msg))
     {}
+
     spdlog_ex(const std::string& msg, int last_errno)
     {
         _msg = msg + ": " + details::os::errno_str(last_errno);
     }
+
     const char* what() const SPDLOG_NOEXCEPT override
     {
         return _msg.c_str();
     }
+
 private:
     std::string _msg;
-
 };
 
 //
@@ -163,5 +164,4 @@ using filename_t = std::wstring;
 using filename_t = std::string;
 #endif
 
-
 } //spdlog

include/spdlog/details/async_log_helper.h

@@ -43,6 +43,7 @@ class async_log_helper
         flush,
         terminate
     };
+
     struct async_msg
     {
         std::string logger_name;
@@ -56,8 +57,14 @@ class async_log_helper
         async_msg() = default;
         ~async_msg() = default;
 
+        explicit async_msg(async_msg_type m_type) :
+            level(level::info),
+            thread_id(0),
+            msg_type(m_type),
+            msg_id(0)
+        {}
 
-async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
+async_msg(async_msg&& other) SPDLOG_NOEXCEPT :
         logger_name(std::move(other.logger_name)),
                     level(std::move(other.level)),
                     time(std::move(other.time)),
@@ -67,13 +74,6 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
                     msg_id(other.msg_id)
         {}
 
-        async_msg(async_msg_type m_type):
-            level(level::info),
-            thread_id(0),
-            msg_type(m_type),
-            msg_id(0)
-        {}
-
         async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
         {
             logger_name = std::move(other.logger_name);
@@ -91,7 +91,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
         async_msg& operator=(const async_msg& other) = delete;
 
         // construct from log_msg
-        async_msg(const details::log_msg& m):
+        explicit async_msg(const details::log_msg& m):
             level(m.level),
             time(m.time),
             thread_id(m.thread_id),
@@ -104,7 +104,6 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
 #endif
         }
 
-
         // copy into log_msg
         void fill_log_msg(log_msg &msg)
         {
@@ -118,28 +117,29 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
     };
 
 public:
-
     using item_type = async_msg;
     using q_type = details::mpmc_bounded_queue<item_type>;
 
     using clock = std::chrono::steady_clock;
 
-
     async_log_helper(formatter_ptr formatter,
-                     const std::vector<sink_ptr>& sinks,
+                     std::vector<sink_ptr> sinks,
                      size_t queue_size,
                      const log_err_handler err_handler,
                      const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
-                     const std::function<void()>& worker_warmup_cb = nullptr,
+                     std::function<void()> worker_warmup_cb = nullptr,
                      const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
-                     const std::function<void()>& worker_teardown_cb = nullptr);
+                     std::function<void()> worker_teardown_cb = nullptr);
 
     void log(const details::log_msg& msg);
 
     // stop logging and join the back thread
     ~async_log_helper();
 
-    void set_formatter(formatter_ptr);
+    async_log_helper(const async_log_helper&) = delete;
+    async_log_helper& operator=(const async_log_helper&) = delete;
+
+    void set_formatter(formatter_ptr msg_formatter);
 
     void flush(bool wait_for_q);
 
@@ -158,7 +158,6 @@ private:
 
     bool _terminate_requested;
 
-
     // overflow policy
     const async_overflow_policy _overflow_policy;
 
@@ -200,23 +199,23 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 inline spdlog::details::async_log_helper::async_log_helper(
     formatter_ptr formatter,
-    const std::vector<sink_ptr>& sinks,
+    std::vector<sink_ptr> sinks,
     size_t queue_size,
     log_err_handler err_handler,
     const async_overflow_policy overflow_policy,
-    const std::function<void()>& worker_warmup_cb,
+    std::function<void()> worker_warmup_cb,
     const std::chrono::milliseconds& flush_interval_ms,
-    const std::function<void()>& worker_teardown_cb):
-    _formatter(formatter),
-    _sinks(sinks),
+    std::function<void()> worker_teardown_cb):
+    _formatter(std::move(formatter)),
+    _sinks(std::move(sinks)),
     _q(queue_size),
-    _err_handler(err_handler),
+    _err_handler(std::move(err_handler)),
     _flush_requested(false),
     _terminate_requested(false),
     _overflow_policy(overflow_policy),
-    _worker_warmup_cb(worker_warmup_cb),
+    _worker_warmup_cb(std::move(worker_warmup_cb)),
     _flush_interval_ms(flush_interval_ms),
-    _worker_teardown_cb(worker_teardown_cb)
+    _worker_teardown_cb(std::move(worker_teardown_cb))
 {
     _worker_thread = std::thread(&async_log_helper::worker_loop, this);
 }
@@ -328,13 +327,10 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
 
     // Handle empty queue..
     // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
-    else
-    {
-        auto now = details::os::now();
-        handle_flush_interval(now, last_flush);
-        sleep_or_yield(now, last_pop);
-        return !_terminate_requested;
-    }
+    auto now = details::os::now();
+    handle_flush_interval(now, last_flush);
+    sleep_or_yield(now, last_pop);
+    return !_terminate_requested;
 }
 
 // flush all sinks if _flush_interval_ms has expired
@@ -352,10 +348,9 @@ inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::
 
 inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
 {
-    _formatter = msg_formatter;
+    _formatter = std::move(msg_formatter);
 }
 
-
 // spin, yield or sleep. use the time passed since last message as a hint
 inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)
 {
@@ -392,8 +387,5 @@ inline void spdlog::details::async_log_helper::wait_empty_q()
 
 inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler)
 {
-    _err_handler = err_handler;
+    _err_handler = std::move(err_handler);
 }
-
-
-

include/spdlog/details/async_logger_impl.h

@@ -17,38 +17,38 @@
 #include <memory>
 
 template<class It>
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
+inline spdlog::async_logger::async_logger(const std::string& name,
         const It& begin,
         const It& end,
         size_t queue_size,
-        const  async_overflow_policy overflow_policy,
+        const async_overflow_policy overflow_policy,
         const std::function<void()>& worker_warmup_cb,
         const std::chrono::milliseconds& flush_interval_ms,
         const std::function<void()>& worker_teardown_cb) :
-    logger(logger_name, begin, end),
+    logger(name, begin, end),
     _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
 {
 }
 
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        sinks_init_list sinks_list,
+inline spdlog::async_logger::async_logger(const std::string& name,
+        sinks_init_list sinks,
         size_t queue_size,
-        const  async_overflow_policy overflow_policy,
+        const async_overflow_policy overflow_policy,
         const std::function<void()>& worker_warmup_cb,
         const std::chrono::milliseconds& flush_interval_ms,
         const std::function<void()>& worker_teardown_cb) :
-    async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
+    async_logger(name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
 
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
+inline spdlog::async_logger::async_logger(const std::string& name,
         sink_ptr single_sink,
         size_t queue_size,
-        const  async_overflow_policy overflow_policy,
+        const async_overflow_policy overflow_policy,
         const std::function<void()>& worker_warmup_cb,
         const std::chrono::milliseconds& flush_interval_ms,
         const std::function<void()>& worker_teardown_cb) :
-    async_logger(logger_name,
+    async_logger(name,
 {
-    single_sink
+    std::move(single_sink)
 }, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
 
 

include/spdlog/details/file_helper.h

@@ -31,9 +31,7 @@ public:
     const int open_tries = 5;
     const int open_interval = 10;
 
-    explicit file_helper() :
-        _fd(nullptr)
-    {}
+    explicit file_helper() = default;
 
     file_helper(const file_helper&) = delete;
     file_helper& operator=(const file_helper&) = delete;
@@ -46,7 +44,6 @@ public:
 
     void open(const filename_t& fname, bool truncate = false)
     {
-
         close();
         auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
         _filename = fname;
@@ -76,7 +73,7 @@ public:
 
     void close()
     {
-        if (_fd)
+        if (_fd != nullptr)
         {
             std::fclose(_fd);
             _fd = nullptr;
@@ -93,8 +90,10 @@ public:
 
     size_t size() const
     {
-        if (!_fd)
+        if (_fd == nullptr)
+        {
             throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
+        }
         return os::filesize(_fd);
     }
 
@@ -137,8 +136,9 @@ public:
         // finally - return a valid base and extension tuple
         return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
     }
+
 private:
-    FILE* _fd;
+    FILE* _fd{ nullptr };
     filename_t _filename;
 };
 }

include/spdlog/details/log_msg.h

@@ -8,7 +8,6 @@
 #include "../common.h"
 #include "../details/os.h"
 
-
 #include <string>
 #include <utility>
 
@@ -21,8 +20,7 @@ struct log_msg
     log_msg() = default;
     log_msg(const std::string *loggers_name, level::level_enum lvl) :
         logger_name(loggers_name),
-        level(lvl),
-        msg_id(0)
+        level(lvl)
     {
 #ifndef SPDLOG_NO_DATETIME
         time = os::now();
@@ -33,18 +31,18 @@ struct log_msg
 #endif
     }
 
-    log_msg(const log_msg& other)  = delete;
+    log_msg(const log_msg& other) = delete;
     log_msg& operator=(log_msg&& other) = delete;
     log_msg(log_msg&& other) = delete;
 
 
-    const std::string *logger_name;
+    const std::string *logger_name{ nullptr };
     level::level_enum level;
     log_clock::time_point time;
     size_t thread_id;
     fmt::MemoryWriter raw;
     fmt::MemoryWriter formatted;
-    size_t msg_id;
+    size_t msg_id{ 0 };
 };
 }
 }

include/spdlog/details/logger_impl.h

@@ -14,14 +14,14 @@
 // create logger with given name, sinks and the default pattern formatter
 // all other ctors will call this one
 template<class It>
-inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
-    _name(logger_name),
+inline spdlog::logger::logger(std::string name, const It& begin, const It& end):
+    _name(std::move(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
+    _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)
     {
@@ -30,16 +30,16 @@ inline spdlog::logger::logger(const std::string& logger_name, const It& begin, c
 }
 
 // ctor with sinks as init list
-inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
-    logger(logger_name, sinks_list.begin(), sinks_list.end())
+inline spdlog::logger::logger(const std::string& name, sinks_init_list sinks):
+    logger(name, sinks.begin(), sinks.end())
 {}
 
 
 // ctor with single sink
-inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
-    logger(logger_name,
+inline spdlog::logger::logger(const std::string& name, spdlog::sink_ptr single_sink):
+    logger(name,
 {
-    single_sink
+    std::move(single_sink)
 })
 {}
 
@@ -49,7 +49,7 @@ inline spdlog::logger::~logger() = default;
 
 inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
 {
-    _set_formatter(msg_formatter);
+    _set_formatter(std::move(msg_formatter));
 }
 
 inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time)
@@ -281,7 +281,7 @@ inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
 
 inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
 {
-    _err_handler = err_handler;
+    _err_handler = std::move(err_handler);
 }
 
 inline spdlog::log_err_handler spdlog::logger::error_handler()
@@ -289,7 +289,6 @@ inline spdlog::log_err_handler spdlog::logger::error_handler()
     return _err_handler;
 }
 
-
 inline void spdlog::logger::flush_on(level::level_enum log_level)
 {
     _flush_level.store(log_level);
@@ -330,9 +329,10 @@ inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_tim
 {
     _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
 }
+
 inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
 {
-    _formatter = msg_formatter;
+    _formatter = std::move(msg_formatter);
 }
 
 inline void spdlog::logger::flush()
@@ -349,7 +349,7 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg)
     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);
-    details::log_msg  err_msg;
+    details::log_msg err_msg;
     err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::default_eol);
     sinks::stderr_sink_mt::instance()->log(err_msg);
     _last_err_time = now;

include/spdlog/details/mpmc_bounded_q.h

@@ -53,13 +53,13 @@ namespace spdlog
 namespace details
 {
 
-template<typename T>
+template <typename T>
 class mpmc_bounded_queue
 {
 public:
-
     using item_type = T;
-    mpmc_bounded_queue(size_t buffer_size)
+
+    explicit mpmc_bounded_queue(size_t buffer_size)
         :max_size_(buffer_size),
          buffer_(new cell_t[buffer_size]),
          buffer_mask_(buffer_size - 1)
@@ -79,6 +79,8 @@ public:
         delete[] buffer_;
     }
 
+    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
+    void operator=(mpmc_bounded_queue const&) = delete;
 
     bool enqueue(T&& data)
     {
@@ -157,7 +159,7 @@ private:
     size_t const max_size_;
 
     static size_t const     cacheline_size = 64;
-    typedef char            cacheline_pad_t[cacheline_size];
+    using cacheline_pad_t = char[cacheline_size];
 
     cacheline_pad_t         pad0_;
     cell_t* const           buffer_;
@@ -167,9 +169,6 @@ private:
     cacheline_pad_t         pad2_;
     std::atomic<size_t>     dequeue_pos_;
     cacheline_pad_t         pad3_;
-
-    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
-    void operator= (mpmc_bounded_queue const&) = delete;
 };
 
 } // ns details

include/spdlog/details/null_mutex.h

@@ -27,7 +27,7 @@ struct null_atomic_int
     int value;
     null_atomic_int() = default;
 
-    null_atomic_int(int val):value(val)
+    explicit null_atomic_int(int val) : value(val)
     {}
 
     int load(std::memory_order) const

include/spdlog/details/os.h

@@ -81,10 +81,10 @@ inline std::tm localtime(const std::time_t &time_tt)
 {
 
 #ifdef _WIN32
-    std::tm tm;
+    std::tm tm {};
     localtime_s(&tm, &time_tt);
 #else
-    std::tm tm;
+    std::tm tm {};
     localtime_r(&time_tt, &tm);
 #endif
     return tm;
@@ -96,15 +96,14 @@ inline std::tm localtime()
     return localtime(now_t);
 }
 
-
 inline std::tm gmtime(const std::time_t &time_tt)
 {
 
 #ifdef _WIN32
-    std::tm tm;
+    std::tm tm {};
     gmtime_s(&tm, &time_tt);
 #else
-    std::tm tm;
+    std::tm tm {};
     gmtime_r(&time_tt, &tm);
 #endif
     return tm;
@@ -170,7 +169,7 @@ inline void prevent_child_fd(FILE *f)
 
 
 //fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
+inline bool fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
 {
 #ifdef _WIN32
 #ifdef SPDLOG_WCHAR_FILENAMES
@@ -220,7 +219,7 @@ inline bool file_exists(const filename_t& filename)
 #endif
     return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
 #else //common linux/unix all have the stat system call
-    struct stat buffer;
+    struct stat buffer {};
     return (stat(filename.c_str(), &buffer) == 0);
 #endif
 }
@@ -250,11 +249,11 @@ inline size_t filesize(FILE *f)
     int fd = fileno(f);
     //64 bits(but not in osx or cygwin, where fstat64 is deprecated)
 #if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
-    struct stat64 st;
+    struct stat64 st {};
     if (fstat64(fd, &st) == 0)
         return static_cast<size_t>(st.st_size);
 #else // unix 32 bits or cygwin
-    struct stat st;
+    struct stat st {};
     if (fstat(fd, &st) == 0)
         return static_cast<size_t>(st.st_size);
 #endif
@@ -318,9 +317,9 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
         }
     };
 
-    long int offset_seconds = helper::calculate_gmt_offset(tm);
+    auto offset_seconds = helper::calculate_gmt_offset(tm);
 #else
-    long int offset_seconds = tm.tm_gmtoff;
+    auto offset_seconds = tm.tm_gmtoff;
 #endif
 
     return static_cast<int>(offset_seconds / 60);
@@ -332,12 +331,12 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
 inline size_t _thread_id()
 {
 #ifdef _WIN32
-    return  static_cast<size_t>(::GetCurrentThreadId());
+    return static_cast<size_t>(::GetCurrentThreadId());
 #elif __linux__
 # if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
 #  define SYS_gettid __NR_gettid
 # endif
-    return  static_cast<size_t>(syscall(SYS_gettid));
+    return static_cast<size_t>(syscall(SYS_gettid));
 #elif __FreeBSD__
     long tid;
     thr_self(&tid);
@@ -403,10 +402,7 @@ inline std::string errno_to_string(char buf[256], int res)
     {
         return std::string(buf);
     }
-    else
-    {
-        return "Unknown error";
-    }
+    return "Unknown error";
 }
 
 // Return errno string (thread safe)
@@ -482,9 +478,9 @@ inline bool in_terminal(FILE* file)
 {
 
 #ifdef _WIN32
-    return _isatty(_fileno(file)) ? true : false;
+    return _isatty(_fileno(file)) != 0;
 #else
-    return isatty(fileno(file)) ? true : false;
+    return isatty(fileno(file)) != 0;
 #endif
 }
 } //os

include/spdlog/details/pattern_formatter_impl.h

@@ -27,27 +27,23 @@ namespace details
 class flag_formatter
 {
 public:
-    virtual ~flag_formatter()
-    {}
+    virtual ~flag_formatter() = default;
     virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////
 // name & level pattern appenders
 ///////////////////////////////////////////////////////////////////////
-namespace
-{
-class name_formatter:public flag_formatter
+class name_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
         msg.formatted << *msg.logger_name;
     }
 };
-}
 
 // log level appender
-class level_formatter:public flag_formatter
+class level_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -56,7 +52,7 @@ class level_formatter:public flag_formatter
 };
 
 // short log level appender
-class short_level_formatter:public flag_formatter
+class short_level_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -80,7 +76,7 @@ static int to12h(const tm& t)
 
 //Abbreviated weekday name
 static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-class a_formatter:public flag_formatter
+class a_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -90,7 +86,7 @@ class a_formatter:public flag_formatter
 
 //Full weekday name
 static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-class A_formatter:public flag_formatter
+class A_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -99,8 +95,8 @@ class A_formatter:public flag_formatter
 };
 
 //Abbreviated month
-static const std::string  months[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec" };
-class b_formatter:public flag_formatter
+static const std::string months[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec" };
+class b_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -110,7 +106,7 @@ class b_formatter:public flag_formatter
 
 //Full month name
 static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-class B_formatter:public flag_formatter
+class B_formatter : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -118,7 +114,6 @@ class B_formatter:public flag_formatter
     }
 };
 
-
 //write 2 ints separated by sep with padding of 2
 static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep)
 {
@@ -133,9 +128,8 @@ static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v
     return w;
 }
 
-
 //Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter SPDLOG_FINAL:public flag_formatter
+class c_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -144,9 +138,8 @@ class c_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-
 // year - 2 digit
-class C_formatter SPDLOG_FINAL:public flag_formatter
+class C_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -154,10 +147,8 @@ class C_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-
-
 // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter SPDLOG_FINAL:public flag_formatter
+class D_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -165,9 +156,8 @@ class D_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-
 // year - 4 digit
-class Y_formatter SPDLOG_FINAL:public flag_formatter
+class Y_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -176,7 +166,7 @@ class Y_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // month 1-12
-class m_formatter SPDLOG_FINAL:public flag_formatter
+class m_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -185,7 +175,7 @@ class m_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // day of month 1-31
-class d_formatter SPDLOG_FINAL:public flag_formatter
+class d_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -193,8 +183,8 @@ class d_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-// hours in 24 format  0-23
-class H_formatter SPDLOG_FINAL:public flag_formatter
+// hours in 24 format 0-23
+class H_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -202,8 +192,8 @@ class H_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-// hours in 12 format  1-12
-class I_formatter SPDLOG_FINAL:public flag_formatter
+// hours in 12 format 1-12
+class I_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -212,7 +202,7 @@ class I_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // minutes 0-59
-class M_formatter SPDLOG_FINAL:public flag_formatter
+class M_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -221,7 +211,7 @@ class M_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // seconds 0-59
-class S_formatter SPDLOG_FINAL:public flag_formatter
+class S_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -230,7 +220,7 @@ class S_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // milliseconds
-class e_formatter SPDLOG_FINAL:public flag_formatter
+class e_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -241,7 +231,7 @@ class e_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // microseconds
-class f_formatter SPDLOG_FINAL:public flag_formatter
+class f_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -252,7 +242,7 @@ class f_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // nanoseconds
-class F_formatter SPDLOG_FINAL:public flag_formatter
+class F_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -262,7 +252,7 @@ class F_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-class E_formatter SPDLOG_FINAL:public flag_formatter
+class E_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -273,7 +263,7 @@ class E_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // AM/PM
-class p_formatter SPDLOG_FINAL:public flag_formatter
+class p_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -281,9 +271,8 @@ class p_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-
 // 12 hour clock 02:55:02 pm
-class r_formatter SPDLOG_FINAL:public flag_formatter
+class r_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -292,7 +281,7 @@ class r_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter SPDLOG_FINAL:public flag_formatter
+class R_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -301,7 +290,7 @@ class R_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter SPDLOG_FINAL:public flag_formatter
+class T_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -310,13 +299,12 @@ class T_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter SPDLOG_FINAL:public flag_formatter
+class z_formatter SPDLOG_FINAL : public flag_formatter
 {
 public:
     const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
 
-    z_formatter():_last_update(std::chrono::seconds(0)), _offset_minutes(0)
-    {}
+    z_formatter() = default;
     z_formatter(const z_formatter&) = delete;
     z_formatter& operator=(const z_formatter&) = delete;
 
@@ -347,13 +335,12 @@ public:
         pad_n_join(msg.formatted, h, m, ':');
     }
 private:
-    log_clock::time_point _last_update;
-    int _offset_minutes;
+    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)
     {
-        using namespace std::chrono;
         std::lock_guard<std::mutex> l(_mutex);
         if (msg.time - _last_update >= cache_refresh)
         {
@@ -364,10 +351,8 @@ private:
     }
 };
 
-
-
 // Thread id
-class t_formatter SPDLOG_FINAL:public flag_formatter
+class t_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -376,7 +361,7 @@ class t_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // Current pid
-class pid_formatter SPDLOG_FINAL:public flag_formatter
+class pid_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -385,7 +370,7 @@ class pid_formatter SPDLOG_FINAL:public flag_formatter
 };
 
 // message counter formatter
-class i_formatter SPDLOG_FINAL :public flag_formatter
+class i_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -393,7 +378,7 @@ class i_formatter SPDLOG_FINAL :public flag_formatter
     }
 };
 
-class v_formatter SPDLOG_FINAL:public flag_formatter
+class v_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -401,7 +386,7 @@ class v_formatter SPDLOG_FINAL:public flag_formatter
     }
 };
 
-class ch_formatter SPDLOG_FINAL:public flag_formatter
+class ch_formatter SPDLOG_FINAL : public flag_formatter
 {
 public:
     explicit ch_formatter(char ch): _ch(ch)
@@ -416,11 +401,11 @@ private:
 
 
 //aggregate user chars to display as is
-class aggregate_formatter SPDLOG_FINAL:public flag_formatter
+class aggregate_formatter SPDLOG_FINAL : public flag_formatter
 {
 public:
-    aggregate_formatter()
-    {}
+    aggregate_formatter() = default;
+
     void add_ch(char ch)
     {
         _str += ch;
@@ -435,7 +420,7 @@ private:
 
 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter SPDLOG_FINAL:public flag_formatter
+class full_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -487,8 +472,9 @@ 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, const std::string& eol)
-    : _eol(eol), _pattern_time(pattern_time)
+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)
 {
     compile_pattern(pattern);
 }
@@ -663,9 +649,10 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
 inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg)
 {
     if (_pattern_time == pattern_time_type::local)
+    {
         return details::os::localtime(log_clock::to_time_t(msg.time));
-    else
-        return details::os::gmtime(log_clock::to_time_t(msg.time));
+    }
+    return details::os::gmtime(log_clock::to_time_t(msg.time));
 }
 
 inline void spdlog::pattern_formatter::format(details::log_msg& msg)

include/spdlog/details/registry.h

@@ -26,9 +26,12 @@ namespace spdlog
 {
 namespace details
 {
-template <class Mutex> class registry_t
+template <class Mutex>
+class registry_t
 {
 public:
+    registry_t<Mutex>(const registry_t<Mutex>&) = delete;
+    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
 
     void register_logger(std::shared_ptr<logger> logger)
     {
@@ -38,7 +41,6 @@ public:
         _loggers[logger_name] = logger;
     }
 
-
     std::shared_ptr<logger> get(const std::string& logger_name)
     {
         std::lock_guard<Mutex> lock(_mutex);
@@ -111,6 +113,7 @@ public:
         std::lock_guard<Mutex> lock(_mutex);
         _loggers.clear();
     }
+
     std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
     {
         return create(logger_name, sinks.begin(), sinks.end());
@@ -194,15 +197,14 @@ public:
     }
 
 private:
-    registry_t<Mutex>() {}
-    registry_t<Mutex>(const registry_t<Mutex>&) = delete;
-    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
+    registry_t<Mutex>() = default;
 
     void throw_if_exists(const std::string &logger_name)
     {
         if (_loggers.find(logger_name) != _loggers.end())
             throw spdlog_ex("logger with name '" + logger_name + "' already exists");
     }
+
     Mutex _mutex;
     std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
     formatter_ptr _formatter;
@@ -212,14 +214,16 @@ private:
     bool _async_mode = false;
     size_t _async_q_size = 0;
     async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
-    std::function<void()> _worker_warmup_cb = nullptr;
+    std::function<void()> _worker_warmup_cb;
     std::chrono::milliseconds _flush_interval_ms;
-    std::function<void()> _worker_teardown_cb = nullptr;
+    std::function<void()> _worker_teardown_cb;
 };
+
 #ifdef SPDLOG_NO_REGISTRY_MUTEX
-typedef registry_t<spdlog::details::null_mutex> registry;
+using registry = registry_t<spdlog::details::null_mutex>;
 #else
-typedef registry_t<std::mutex> registry;
+using registry = registry_t<std::mutex>;
 #endif
+
 }
 }

include/spdlog/details/spdlog_impl.h

@@ -34,7 +34,7 @@
 
 inline void spdlog::register_logger(std::shared_ptr<logger> logger)
 {
-    return details::registry::instance().register_logger(logger);
+    return details::registry::instance().register_logger(std::move(logger));
 }
 
 inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
@@ -183,13 +183,11 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
 }
 
 //Create logger with multiple sinks
-
 inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)
 {
     return details::registry::instance().create(logger_name, sinks);
 }
 
-
 template <typename Sink, typename... Args>
 inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
 {
@@ -197,7 +195,6 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
     return details::registry::instance().create(logger_name, { sink });
 }
 
-
 template<class It>
 inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
 {
@@ -224,7 +221,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& l
 
 inline void spdlog::set_formatter(spdlog::formatter_ptr f)
 {
-    details::registry::instance().formatter(f);
+    details::registry::instance().formatter(std::move(f));
 }
 
 inline void spdlog::set_pattern(const std::string& format_string)
@@ -244,10 +241,9 @@ inline void spdlog::flush_on(level::level_enum log_level)
 
 inline void spdlog::set_error_handler(log_err_handler handler)
 {
-    return details::registry::instance().set_error_handler(handler);
+    return details::registry::instance().set_error_handler(std::move(handler));
 }
 
-
 inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
 {
     details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
@@ -260,7 +256,7 @@ inline void spdlog::set_sync_mode()
 
 inline void spdlog::apply_all(std::function<void(std::shared_ptr<logger>)> fun)
 {
-    details::registry::instance().apply_all(fun);
+    details::registry::instance().apply_all(std::move(fun));
 }
 
 inline void spdlog::drop_all()

include/spdlog/formatter.h

@@ -21,18 +21,18 @@ class flag_formatter;
 class formatter
 {
 public:
-    virtual ~formatter() {}
+    virtual ~formatter() = default;
     virtual void format(details::log_msg& msg) = 0;
 };
 
 class pattern_formatter SPDLOG_FINAL : public formatter
 {
-
 public:
-    explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string& eol = spdlog::details::os::default_eol);
+    explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
     pattern_formatter(const pattern_formatter&) = delete;
     pattern_formatter& operator=(const pattern_formatter&) = delete;
     void format(details::log_msg& msg) override;
+
 private:
     const std::string _eol;
     const std::string _pattern;
@@ -45,4 +45,3 @@ private:
 }
 
 #include "details/pattern_formatter_impl.h"
-

include/spdlog/logger.h

@@ -25,16 +25,17 @@ namespace spdlog
 class logger
 {
 public:
-    logger(const std::string& logger_name, sink_ptr single_sink);
-    logger(const std::string& name, sinks_init_list);
-    template<class It>
-    logger(const std::string& name, const It& begin, const It& end);
+    logger(const std::string& name, sink_ptr single_sink);
+    logger(const std::string& name, sinks_init_list sinks);
+
+    template <class It>
+    logger(std::string name, const It& begin, const It& end);
 
     virtual ~logger();
+
     logger(const logger&) = delete;
     logger& operator=(const logger&) = delete;
 
-
     template <typename... Args> void log(level::level_enum lvl, const char* fmt, const Args&... args);
     template <typename... Args> void log(level::level_enum lvl, const char* msg);
     template <typename Arg1, typename... Args> void trace(const char* fmt, const Arg1&, const Args&... args);
@@ -44,7 +45,6 @@ public:
     template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args);
     template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args);
 
-
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
     template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg);
     template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args);
@@ -57,19 +57,19 @@ public:
 #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
     template <typename T> void log(level::level_enum lvl, const T&);
-    template <typename T> void trace(const T&);
-    template <typename T> void debug(const T&);
-    template <typename T> void info(const T&);
-    template <typename T> void warn(const T&);
-    template <typename T> void error(const T&);
-    template <typename T> void critical(const T&);
-
-    bool should_log(level::level_enum) const;
-    void set_level(level::level_enum);
+    template <typename T> void trace(const T& msg);
+    template <typename T> void debug(const T& msg);
+    template <typename T> void info(const T& msg);
+    template <typename T> void warn(const T& msg);
+    template <typename T> void error(const T& msg);
+    template <typename T> void critical(const T& msg);
+
+    bool should_log(level::level_enum msg_level) const;
+    void set_level(level::level_enum log_level);
     level::level_enum level() const;
     const std::string& name() const;
-    void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local);
-    void set_formatter(formatter_ptr);
+    void set_pattern(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local);
+    void set_formatter(formatter_ptr msg_formatter);
 
     // automatically call flush() if message level >= log_level
     void flush_on(level::level_enum log_level);
@@ -79,22 +79,22 @@ public:
     const std::vector<sink_ptr>& sinks() const;
 
     // error handler
-    virtual void set_error_handler(log_err_handler);
+    virtual void set_error_handler(log_err_handler err_handler);
     virtual log_err_handler error_handler();
 
 protected:
-    virtual void _sink_it(details::log_msg&);
-    virtual void _set_pattern(const std::string&, pattern_time_type);
-    virtual void _set_formatter(formatter_ptr);
+    virtual void _sink_it(details::log_msg& msg);
+    virtual void _set_pattern(const std::string& pattern, pattern_time_type pattern_time);
+    virtual void _set_formatter(formatter_ptr msg_formatter);
 
     // default error handler: print the error to stderr with the max rate of 1 message/minute
     virtual void _default_err_handler(const std::string &msg);
 
     // return true if the given message level should trigger a flush
-    bool _should_flush_on(const details::log_msg&);
+    bool _should_flush_on(const details::log_msg& msg);
 
     // increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
-    void _incr_msg_counter(details::log_msg &msg);
+    void _incr_msg_counter(details::log_msg& msg);
 
     const std::string _name;
     std::vector<sink_ptr> _sinks;

include/spdlog/sinks/ansicolor_sink.h

@@ -23,10 +23,10 @@ namespace sinks
  * If no color terminal detected, omit the escape codes.
  */
 template <class Mutex>
-class ansicolor_sink: public base_sink<Mutex>
+class ansicolor_sink : public base_sink<Mutex>
 {
 public:
-    ansicolor_sink(FILE* file): target_file_(file)
+    explicit ansicolor_sink(FILE* file) : target_file_(file)
     {
         should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal();
         colors_[level::trace] = cyan;
@@ -37,7 +37,8 @@ public:
         colors_[level::critical] = bold + on_red;
         colors_[level::off] = reset;
     }
-    virtual ~ansicolor_sink()
+
+    ~ansicolor_sink() override
     {
         _flush();
     }
@@ -79,7 +80,7 @@ public:
     const std::string on_white = "\033[47m";
 
 protected:
-    virtual void _sink_it(const details::log_msg& msg) override
+    void _sink_it(const details::log_msg& msg) override
     {
         // Wrap the originally formatted message in color codes.
         // If color is not supported in the terminal, log as is instead.
@@ -102,6 +103,7 @@ protected:
     {
         fflush(target_file_);
     }
+
     FILE* target_file_;
     bool should_do_colors_;
     std::unordered_map<level::level_enum, std::string, level::level_hasher> colors_;
@@ -116,6 +118,9 @@ public:
     {}
 };
 
+using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<std::mutex>;
+using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::null_mutex>;
+
 template<class Mutex>
 class ansicolor_stderr_sink: public ansicolor_sink<Mutex>
 {
@@ -124,11 +129,8 @@ public:
     {}
 };
 
-typedef ansicolor_stdout_sink<std::mutex> ansicolor_stdout_sink_mt;
-typedef ansicolor_stdout_sink<details::null_mutex> ansicolor_stdout_sink_st;
-
-typedef ansicolor_stderr_sink<std::mutex> ansicolor_stderr_sink_mt;
-typedef ansicolor_stderr_sink<details::null_mutex> ansicolor_stderr_sink_st;
+using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<std::mutex>;
+using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::null_mutex>;
 
 } // namespace sinks
 } // namespace spdlog

include/spdlog/sinks/base_sink.h

@@ -22,11 +22,10 @@ namespace spdlog
 namespace sinks
 {
 template<class Mutex>
-class base_sink:public sink
+class base_sink : public sink
 {
 public:
-    base_sink():_mutex() {}
-    virtual ~base_sink() = default;
+    base_sink() = default;
 
     base_sink(const base_sink&) = delete;
     base_sink& operator=(const base_sink&) = delete;
@@ -36,6 +35,7 @@ public:
         std::lock_guard<Mutex> lock(_mutex);
         _sink_it(msg);
     }
+
     void flush() SPDLOG_FINAL override
     {
         std::lock_guard<Mutex> lock(_mutex);

include/spdlog/sinks/dist_sink.h

@@ -22,13 +22,12 @@ namespace spdlog
 namespace sinks
 {
 template<class Mutex>
-class dist_sink: public base_sink<Mutex>
+class dist_sink : public base_sink<Mutex>
 {
 public:
     explicit dist_sink() :_sinks() {}
     dist_sink(const dist_sink&) = delete;
     dist_sink& operator=(const dist_sink&) = delete;
-    virtual ~dist_sink() = default;
 
 protected:
     std::vector<std::shared_ptr<sink>> _sinks;
@@ -51,8 +50,6 @@ protected:
     }
 
 public:
-
-
     void add_sink(std::shared_ptr<sink> sink)
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
@@ -66,7 +63,8 @@ public:
     }
 };
 
-typedef dist_sink<std::mutex> dist_sink_mt;
-typedef dist_sink<details::null_mutex> dist_sink_st;
+using dist_sink_mt = dist_sink<std::mutex>;
+using dist_sink_st = dist_sink<details::null_mutex>;
+
 }
 }

include/spdlog/sinks/file_sinks.h

@@ -25,8 +25,8 @@ namespace sinks
 /*
  * Trivial file sink with single file as target
  */
-template<class Mutex>
-class simple_file_sink SPDLOG_FINAL : public base_sink < Mutex >
+template <class Mutex>
+class simple_file_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
 public:
     explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false)
@@ -46,32 +46,32 @@ protected:
         if(_force_flush)
             _file_helper.flush();
     }
+
     void _flush() override
     {
         _file_helper.flush();
     }
+
 private:
     details::file_helper _file_helper;
     bool _force_flush;
 };
 
-typedef simple_file_sink<std::mutex> simple_file_sink_mt;
-typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
+using simple_file_sink_mt = simple_file_sink<std::mutex>;
+using simple_file_sink_st = simple_file_sink<details::null_mutex>;
 
 /*
  * Rotating file sink based on size
  */
-template<class Mutex>
-class rotating_file_sink SPDLOG_FINAL : public base_sink < Mutex >
+template <class Mutex>
+class rotating_file_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
 public:
-    rotating_file_sink(const filename_t &base_filename,
+    rotating_file_sink(filename_t base_filename,
                        std::size_t max_size, std::size_t max_files) :
-        _base_filename(base_filename),
+        _base_filename(std::move(base_filename)),
         _max_size(max_size),
-        _max_files(max_files),
-        _current_size(0),
-        _file_helper()
+        _max_files(max_files)
     {
         _file_helper.open(calc_filename(_base_filename, 0));
         _current_size = _file_helper.size(); //expensive. called only once
@@ -82,7 +82,7 @@ public:
     static filename_t calc_filename(const filename_t& filename, std::size_t index)
     {
         typename std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
-        if (index)
+        if (index != 0u)
         {
             filename_t basename, ext;
             std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename);
@@ -112,7 +112,6 @@ protected:
         _file_helper.flush();
     }
 
-
 private:
     // Rotate files:
     // log.txt -> log.1.txt
@@ -135,13 +134,14 @@ private:
                     throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target), errno);
                 }
             }
-            if (details::file_helper::file_exists(src) && details::os::rename(src, target))
+            if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0)
             {
                 throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
             }
         }
         _file_helper.reopen(true);
     }
+
     filename_t _base_filename;
     std::size_t _max_size;
     std::size_t _max_files;
@@ -149,8 +149,8 @@ private:
     details::file_helper _file_helper;
 };
 
-typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
-typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
+using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
+using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
 
 /*
  * Default generator of daily log file names.
@@ -195,9 +195,10 @@ class daily_file_sink SPDLOG_FINAL :public base_sink < Mutex >
 public:
     //create daily file sink which rotates on given time
     daily_file_sink(
-        const filename_t& base_filename,
+        filename_t base_filename,
         int rotation_hour,
-        int rotation_minute) : _base_filename(base_filename),
+        int rotation_minute) :
+        _base_filename(std::move(base_filename)),
         _rotation_h(rotation_hour),
         _rotation_m(rotation_minute)
     {
@@ -235,9 +236,10 @@ private:
         date.tm_sec = 0;
         auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
         if (rotation_time > now)
+        {
             return rotation_time;
-        else
-            return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24));
+        }
+        return{ rotation_time + std::chrono::hours(24) };
     }
 
     filename_t _base_filename;
@@ -247,7 +249,8 @@ private:
     details::file_helper _file_helper;
 };
 
-typedef daily_file_sink<std::mutex> daily_file_sink_mt;
-typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
+using daily_file_sink_mt = daily_file_sink<std::mutex>;
+using daily_file_sink_st = daily_file_sink<details::null_mutex>;
+
 }
 }

include/spdlog/sinks/msvc_sink.h

@@ -23,15 +23,13 @@ namespace sinks
 * MSVC sink (logging using OutputDebugStringA)
 */
 template<class Mutex>
-class msvc_sink : public base_sink < Mutex >
+class msvc_sink : public base_sink<Mutex>
 {
 public:
     explicit msvc_sink()
     {
     }
 
-
-
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
@@ -42,8 +40,8 @@ protected:
     {}
 };
 
-typedef msvc_sink<std::mutex> msvc_sink_mt;
-typedef msvc_sink<details::null_mutex> msvc_sink_st;
+using msvc_sink_mt = msvc_sink<std::mutex>;
+using msvc_sink_st = msvc_sink<details::null_mutex>;
 
 }
 }

include/spdlog/sinks/null_sink.h

@@ -16,7 +16,7 @@ namespace sinks
 {
 
 template <class Mutex>
-class null_sink : public base_sink < Mutex >
+class null_sink : public base_sink<Mutex>
 {
 protected:
     void _sink_it(const details::log_msg&) override
@@ -26,8 +26,9 @@ protected:
     {}
 
 };
-typedef null_sink<details::null_mutex> null_sink_st;
-typedef null_sink<details::null_mutex> null_sink_mt;
+
+using null_sink_mt = null_sink<details::null_mutex>;
+using null_sink_st = null_sink<details::null_mutex>;
 
 }
 }

include/spdlog/sinks/ostream_sink.h

@@ -16,13 +16,12 @@ namespace spdlog
 namespace sinks
 {
 template<class Mutex>
-class ostream_sink: public base_sink<Mutex>
+class ostream_sink : public base_sink<Mutex>
 {
 public:
     explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}
     ostream_sink(const ostream_sink&) = delete;
     ostream_sink& operator=(const ostream_sink&) = delete;
-    virtual ~ostream_sink() = default;
 
 protected:
     void _sink_it(const details::log_msg& msg) override
@@ -41,7 +40,8 @@ protected:
     bool _force_flush;
 };
 
-typedef ostream_sink<std::mutex> ostream_sink_mt;
-typedef ostream_sink<details::null_mutex> ostream_sink_st;
+using ostream_sink_mt = ostream_sink<std::mutex>;
+using ostream_sink_st = ostream_sink<details::null_mutex>;
+
 }
 }

include/spdlog/sinks/sink.h

@@ -3,7 +3,6 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
-
 #pragma once
 
 #include "../details/log_msg.h"
@@ -15,12 +14,8 @@ namespace sinks
 class sink
 {
 public:
-    sink()
-    {
-        _level = level::trace;
-    }
+    virtual ~sink() = default;
 
-    virtual ~sink() {}
     virtual void log(const details::log_msg& msg) = 0;
     virtual void flush() = 0;
 
@@ -29,8 +24,7 @@ public:
     level::level_enum level() const;
 
 private:
-    level_t _level;
-
+    level_t _level{ level::trace };
 };
 
 inline bool sink::should_log(level::level_enum msg_level) const
@@ -50,4 +44,3 @@ inline level::level_enum sink::level() const
 
 }
 }
-

include/spdlog/sinks/stdout_sinks.h

@@ -21,14 +21,16 @@ template <class Mutex>
 class stdout_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
     using MyType = stdout_sink<Mutex>;
+
 public:
-    stdout_sink()
-    {}
+    explicit stdout_sink() = default;
+
     static std::shared_ptr<MyType> instance()
     {
         static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
         return instance;
     }
+
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
@@ -42,22 +44,23 @@ protected:
     }
 };
 
-typedef stdout_sink<details::null_mutex> stdout_sink_st;
-typedef stdout_sink<std::mutex> stdout_sink_mt;
-
+using stdout_sink_mt = stdout_sink<std::mutex>;
+using stdout_sink_st = stdout_sink<details::null_mutex>;
 
 template <class Mutex>
 class stderr_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
     using MyType = stderr_sink<Mutex>;
+
 public:
-    stderr_sink()
-    {}
+    explicit stderr_sink() = default;
+
     static std::shared_ptr<MyType> instance()
     {
         static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
         return instance;
     }
+
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
@@ -71,7 +74,8 @@ protected:
     }
 };
 
-typedef stderr_sink<std::mutex> stderr_sink_mt;
-typedef stderr_sink<details::null_mutex> stderr_sink_st;
+using stderr_sink_mt = stderr_sink<std::mutex>;
+using stderr_sink_st = stderr_sink<details::null_mutex>;
+
 }
 }

include/spdlog/sinks/syslog_sink.h

@@ -44,7 +44,8 @@ public:
         //set ident to be program name if empty
         ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);
     }
-    ~syslog_sink()
+
+    ~syslog_sink() override
     {
         ::closelog();
     }

include/spdlog/sinks/wincolor_sink.h

@@ -21,8 +21,8 @@ namespace sinks
 /*
  * Windows color console sink. Uses WriteConsoleA to write to the console with colors
  */
-template<class Mutex>
-class wincolor_sink: public  base_sink<Mutex>
+template <class Mutex>
+class wincolor_sink : public base_sink<Mutex>
 {
 public:
     const WORD BOLD = FOREGROUND_INTENSITY;
@@ -42,7 +42,7 @@ public:
         colors_[level::off] = 0;
     }
 
-    virtual ~wincolor_sink()
+    ~wincolor_sink() override
     {
         this->flush();
     }
@@ -50,7 +50,7 @@ public:
     wincolor_sink(const wincolor_sink& other) = delete;
     wincolor_sink& operator=(const wincolor_sink& other) = delete;
 
-    // change the  color for the given level
+    // change the color for the given level
     void set_color(level::level_enum level, WORD color)
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
@@ -58,7 +58,7 @@ public:
     }
 
 protected:
-    virtual void _sink_it(const details::log_msg& msg) override
+    void _sink_it(const details::log_msg& msg) override
     {
         auto color = colors_[msg.level];
         auto orig_attribs = set_console_attribs(color);
@@ -66,7 +66,7 @@ protected:
         SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
     }
 
-    virtual void _flush() override
+    void _flush() override
     {
         // windows console always flushed?
     }
@@ -85,37 +85,37 @@ private:
         back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY));
         // keep the background color unchanged
         SetConsoleTextAttribute(out_handle_, attribs | back_color);
-        return  orig_buffer_info.wAttributes; //return orig attribs
+        return orig_buffer_info.wAttributes; //return orig attribs
     }
 };
 
 //
 // windows color console to stdout
 //
-template<class Mutex>
-class wincolor_stdout_sink: public wincolor_sink<Mutex>
+template <class Mutex>
+class wincolor_stdout_sink : public wincolor_sink<Mutex>
 {
 public:
     wincolor_stdout_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_OUTPUT_HANDLE))
     {}
 };
 
-typedef wincolor_stdout_sink<std::mutex> wincolor_stdout_sink_mt;
-typedef wincolor_stdout_sink<details::null_mutex> wincolor_stdout_sink_st;
+using wincolor_stdout_sink_mt = wincolor_stdout_sink<std::mutex>;
+using wincolor_stdout_sink_st = wincolor_stdout_sink<details::null_mutex>;
 
 //
 // windows color console to stderr
 //
-template<class Mutex>
-class wincolor_stderr_sink: public wincolor_sink<Mutex>
+template <class Mutex>
+class wincolor_stderr_sink : public wincolor_sink<Mutex>
 {
 public:
     wincolor_stderr_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_ERROR_HANDLE))
     {}
 };
 
-typedef wincolor_stderr_sink<std::mutex> wincolor_stderr_sink_mt;
-typedef wincolor_stderr_sink<details::null_mutex> wincolor_stderr_sink_st;
+using wincolor_stderr_sink_mt = wincolor_stderr_sink<std::mutex>;
+using wincolor_stderr_sink_st = wincolor_stderr_sink<details::null_mutex>;
 
 }
 }

include/spdlog/sinks/windebug_sink.h

@@ -17,11 +17,11 @@ namespace sinks
 /*
 * Windows debug sink (logging using OutputDebugStringA, synonym for msvc_sink)
 */
-template<class Mutex>
+template <class Mutex>
 using windebug_sink = msvc_sink<Mutex>;
 
-typedef msvc_sink_mt windebug_sink_mt;
-typedef msvc_sink_st windebug_sink_st;
+using windebug_sink_mt = msvc_sink_mt;
+using windebug_sink_st = msvc_sink_st;
 
 }
 }

include/spdlog/spdlog.h

@@ -46,7 +46,7 @@ void flush_on(level::level_enum log_level);
 //
 // Set global error handler
 //
-void set_error_handler(log_err_handler);
+void set_error_handler(log_err_handler handler);
 
 //
 // Turn on async mode (off by default) and set the queue size for each async_logger.
@@ -56,7 +56,7 @@ void set_error_handler(log_err_handler);
 //
 // async_overflow_policy (optional, block_retry by default):
 //    async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
-//    async_overflow_policy::discard_log_msg - never block and discard any new messages when queue  overflows.
+//    async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows.
 //
 // worker_warmup_cb (optional):
 //     callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
@@ -84,7 +84,7 @@ std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const
 std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
 
 //
-// Create file logger which creates new file on the given time (default in  midnight):
+// Create file logger which creates new file on the given time (default in midnight):
 //
 std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
 std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
@@ -129,7 +129,7 @@ std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_b
 // Example:
 // spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename");
 template <typename Sink, typename... Args>
-std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
+std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args... args);
 
 // Create and register an async logger with a single sink
 std::shared_ptr<logger> create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);

include/spdlog/tweakme.h

@@ -54,7 +54,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment if logger name logging is not needed.
-// This will prevent spdlog from copying the logger name  on each log call.
+// This will prevent spdlog from copying the logger name on each log call.
 //
 // #define SPDLOG_NO_NAME
 ///////////////////////////////////////////////////////////////////////////////
@@ -156,5 +156,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to customize level names (e.g. "MT TRACE")
 //
-// #define SPDLOG_LEVEL_NAMES  { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" }
+// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" }
 ///////////////////////////////////////////////////////////////////////////////

tests/file_helper.cpp

@@ -3,7 +3,8 @@
 */
 #include "includes.h"
 
-using namespace spdlog::details;
+using spdlog::details::log_msg;
+using spdlog::details::file_helper;
 
 static const std::string target_filename = "logs/file_helper_test.txt";
 
@@ -15,7 +16,6 @@ static void write_with_helper(file_helper &helper, size_t howmany)
     helper.flush();
 }
 
-
 TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
 {
     prepare_logdir();
@@ -25,8 +25,6 @@ TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
     REQUIRE(helper.filename() == target_filename);
 }
 
-
-
 TEST_CASE("file_helper_size", "[file_helper::size()]]")
 {
     prepare_logdir();
@@ -40,7 +38,6 @@ TEST_CASE("file_helper_size", "[file_helper::size()]]")
     REQUIRE(get_filesize(target_filename) == expected_size);
 }
 
-
 TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]")
 {
     prepare_logdir();
@@ -73,8 +70,6 @@ TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]")
     REQUIRE(helper.size() == expected_size);
 }
 
-
-
 static void test_split_ext(const char* fname, const char* expect_base, const char* expect_ext)
 {
     spdlog::filename_t filename(fname);
@@ -91,7 +86,6 @@ static void test_split_ext(const char* fname, const char* expect_base, const cha
     REQUIRE(ext == expected_ext);
 }
 
-
 TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion()]]")
 {
     test_split_ext("mylog.txt", "mylog", ".txt");
@@ -113,6 +107,3 @@ TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion(
     test_split_ext(".", ".", "");
     test_split_ext("..txt", ".", ".txt");
 }
-
-
-

tests/test_misc.cpp

-
 #include "includes.h"
 
 template<class T>
@@ -16,11 +15,6 @@ std::string log_info(const T& what, spdlog::level::level_enum logger_level = spd
     return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));
 }
 
-
-
-
-
-
 TEST_CASE("basic_logging ", "[basic_logging]")
 {
     //const char

tests/test_pattern_formatter.cpp

 #include "includes.h"
 
 // log to str and return it
-static std::string log_to_str(const std::string& msg, std::shared_ptr<spdlog::formatter> formatter = nullptr)
+static std::string log_to_str(const std::string& msg, const std::shared_ptr<spdlog::formatter>& formatter = nullptr)
 {
     std::ostringstream oss;
     auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
@@ -11,6 +11,7 @@ static std::string log_to_str(const std::string& msg, std::shared_ptr<spdlog::fo
     oss_logger.info(msg);
     return oss.str();
 }
+
 TEST_CASE("custom eol", "[pattern_formatter]")
 {
     std::string msg = "Hello custom eol test";
@@ -38,7 +39,6 @@ TEST_CASE("level", "[pattern_formatter]")
     REQUIRE(log_to_str("Some message", formatter) == "[info] Some message\n");
 }
 
-
 TEST_CASE("short level", "[pattern_formatter]")
 {
     auto formatter = std::make_shared<spdlog::pattern_formatter>("[%L] %v", spdlog::pattern_time_type::local, "\n");
@@ -51,19 +51,11 @@ TEST_CASE("name", "[pattern_formatter]")
     REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n");
 }
 
-
 TEST_CASE("date MM/DD/YY ", "[pattern_formatter]")
 {
-    using namespace::std::chrono;
     auto formatter = std::make_shared<spdlog::pattern_formatter>("%D %v", spdlog::pattern_time_type::local, "\n");
     auto now_tm = spdlog::details::os::localtime();
     std::stringstream oss;
     oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n";
     REQUIRE(log_to_str("Some message", formatter) == oss.str());
 }
-
-
-
-
-
-