Merge 8daacd5eed into 56b3a17e56

CMakeLists.txt

@@ -57,6 +57,14 @@ target_include_directories(
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )
+#Setting thread dependency to Target spdlog, neded for examples,bench,tests
+IF ( MINGW )
+FIND_PACKAGE( Boost 1.62  REQUIRED COMPONENTS thread)
+target_link_libraries(spdlog INTERFACE Boost::thread )
+else()
+find_package(Threads REQUIRED)
+target_link_libraries(spdlog INTERFACE Threads::Threads )
+endif()
 
 set(HEADER_BASE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 

bench/CMakeLists.txt

@@ -33,16 +33,15 @@ if(NOT TARGET spdlog)
   find_package(spdlog CONFIG REQUIRED)
 endif()
 
-find_package(Threads REQUIRED)
 
 add_executable(bench bench.cpp)
-target_link_libraries(bench spdlog::spdlog Threads::Threads -flto)
+target_link_libraries(bench spdlog::spdlog)
 
 add_executable(async_bench async_bench.cpp)
-target_link_libraries(async_bench spdlog::spdlog Threads::Threads)
+target_link_libraries(async_bench spdlog::spdlog)
 
 add_executable(latency latency.cpp)
-target_link_libraries(latency spdlog::spdlog Threads::Threads)
+target_link_libraries(latency spdlog::spdlog)
 
 
 

bench/async_bench.cpp

@@ -113,7 +113,11 @@ void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany)
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count)
 {
-    using std::chrono::high_resolution_clock;
+    using spdlog::chrono::high_resolution_clock;
+    using spdlog::chrono::duration_cast;
+    using spdlog::chrono::duration;
+    using spdlog::details::thread;
+
     vector<thread> threads;
     auto start = high_resolution_clock::now();
 
@@ -122,9 +126,9 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_co
     for (int t = 0; t < thread_count; ++t)
     {
         if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
+            threads.push_back(thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
         else
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
+            threads.push_back(thread(thread_fun, logger, msgs_per_thread));
     }
 
     for (auto &t : threads)

bench/bench.cpp

@@ -18,12 +18,10 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <thread>
 
-using namespace std;
-using namespace std::chrono;
 using namespace spdlog;
 using namespace spdlog::sinks;
+using namespace std;
 using namespace utils;
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log);
@@ -106,7 +104,7 @@ int main(int argc, char *argv[])
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
-    using std::chrono::high_resolution_clock;
+    using chrono::high_resolution_clock;
     cout << log->name() << "...\t\t" << flush;
     auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
@@ -115,7 +113,7 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
     }
 
     auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
+    auto delta_d = spdlog::chrono::duration_cast<spdlog::chrono::duration<double>>(delta).count();
 
     cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
     spdlog::drop(log->name());
@@ -123,13 +121,13 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
 {
-    using std::chrono::high_resolution_clock;
+    using spdlog::chrono::high_resolution_clock;
     cout << log->name() << "...\t\t" << flush;
-    vector<thread> threads;
+    vector<spdlog::details::thread> threads;
     auto start = high_resolution_clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
-        threads.push_back(std::thread([&]() {
+        threads.push_back(spdlog::details::thread([&]() {
             for (int j = 0; j < howmany / thread_count; j++)
             {
                 log->info("Hello logger: msg number {}", j);
@@ -143,6 +141,6 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
     };
 
     auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
+    auto delta_d = spdlog::chrono::duration_cast<spdlog::chrono::duration<double>>(delta).count();
     cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }

bench/latency.cpp

@@ -18,10 +18,8 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <thread>
 
 using namespace std;
-using namespace std::chrono;
 using namespace spdlog;
 using namespace spdlog::sinks;
 using namespace utils;
@@ -99,10 +97,9 @@ int main(int, char *[])
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
-    using namespace std::chrono;
+    using spdlog::chrono::high_resolution_clock;
-    using chrono::high_resolution_clock;
+    using spdlog::chrono::milliseconds;
-    using chrono::milliseconds;
+    using spdlog::chrono::nanoseconds;
-    using chrono::nanoseconds;
 
     cout << log->name() << "...\t\t" << flush;
     nanoseconds total_nanos = nanoseconds::zero();
@@ -120,22 +117,24 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
 {
-    using namespace std::chrono;
+
-    using chrono::high_resolution_clock;
+    using spdlog::chrono::high_resolution_clock;
-    using chrono::milliseconds;
+    using spdlog::chrono::milliseconds;
-    using chrono::nanoseconds;
+    using spdlog::chrono::nanoseconds;
+    using spdlog::chrono::duration_cast;
+    using spdlog::details::thread;
 
     cout << log->name() << "...\t\t" << flush;
     vector<thread> threads;
     std::atomic<nanoseconds::rep> total_nanos{0};
     for (int t = 0; t < thread_count; ++t)
     {
-        threads.push_back(std::thread([&]() {
+        threads.push_back(thread([&]() {
             for (int j = 0; j < howmany / thread_count; j++)
             {
                 auto start = high_resolution_clock::now();
                 log->info("Hello logger: msg number {}", j);
-                auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
+                auto delta_nanos = duration_cast<nanoseconds>(high_resolution_clock::now() - start);
                 total_nanos += delta_nanos.count();
             }
         }));

example/CMakeLists.txt

@@ -32,10 +32,10 @@ endif()
 find_package(Threads REQUIRED)
 
 add_executable(example example.cpp)
-target_link_libraries(example spdlog::spdlog Threads::Threads)
+target_link_libraries(example spdlog::spdlog)
 
 add_executable(multisink multisink.cpp)
-target_link_libraries(multisink spdlog::spdlog Threads::Threads)
+target_link_libraries(multisink spdlog::spdlog)
 
 enable_testing()
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")

example/example.cpp

@@ -48,7 +48,7 @@ int main(int, char *[])
 
         // flush all *registered* loggers using a worker thread every 3 seconds.
         // note: registered loggers *must* be thread safe for this to work correctly!
-        spdlog::flush_every(std::chrono::seconds(3));
+        spdlog::flush_every(spdlog::chrono::seconds(3));
 
         // apply some function on all registered loggers
         spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });

include/spdlog/async.h

@@ -21,8 +21,6 @@
 #include "spdlog/details/registry.h"
 #include "spdlog/details/thread_pool.h"
 
-#include <memory>
-#include <mutex>
 
 namespace spdlog {
 
@@ -42,7 +40,7 @@ struct async_factory_impl
         auto &registry_inst = details::registry::instance();
 
         // create global thread pool if not already exists..
-        std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
+        lock_guard<recursive_mutex> tp_lock(registry_inst.tp_mutex());
         auto tp = registry_inst.get_tp();
         if (tp == nullptr)
         {

include/spdlog/async_logger.h

@@ -22,10 +22,6 @@
 #include "spdlog/common.h"
 #include "spdlog/logger.h"
 
-#include <chrono>
-#include <memory>
-#include <string>
-
 namespace spdlog {
 
 // Async overflow policy - block by default.

include/spdlog/common.h

@@ -8,7 +8,26 @@
 #include "spdlog/tweakme.h"
 
 #include <atomic>
-#include <chrono>
+
+#if defined(__MINGW32__)
+# define SPDLOG_USE_BOOST_THREAD
+# define SPDLOG_USE_BOOST_CHRONO
+#endif
+
+#if defined(SPDLOG_USE_BOOST_THREAD)
+# define SPDLOG_USE_BOOST_CHRONO
+# include <boost/thread.hpp>
+#else
+# include <mutex>
+# include <thread>
+# include <condition_variable>
+#endif
+#if defined(SPDLOG_USE_BOOST_CHRONO)
+# include <boost/chrono.hpp>
+#else
+# include <chrono>
+#endif
+
 #include <functional>
 #include <initializer_list>
 #include <memory>
@@ -57,7 +76,36 @@ namespace sinks {
 class sink;
 }
 
-using log_clock = std::chrono::system_clock;
+// choose thread/mutex 'implementation'
+#if defined(SPDLOG_USE_BOOST_THREAD)
+// import into namespace spdlog
+namespace details {
+    using boost::condition_variable;
+    using boost::thread;
+    using boost::unique_lock;
+} // namespace details
+using boost::recursive_mutex;
+using boost::lock_guard;
+using boost::mutex;
+#else
+namespace details {
+    using std::condition_variable;
+    using std::thread;
+    using std::unique_lock;
+} // namespace details
+using std::recursive_mutex;
+using std::lock_guard;
+using std::mutex;
+#endif
+
+// choose chrono implementation
+#if defined(SPDLOG_USE_BOOST_CHRONO)
+namespace chrono = boost::chrono;
+#else
+namespace chrono = std::chrono;
+#endif
+
+using log_clock = chrono::system_clock;
 using sink_ptr = std::shared_ptr<sinks::sink>;
 using sinks_init_list = std::initializer_list<sink_ptr>;
 using log_err_handler = std::function<void(const std::string &err_msg)>;

include/spdlog/details/async_logger_impl.h

@@ -10,9 +10,6 @@
 
 #include "spdlog/details/thread_pool.h"
 
-#include <chrono>
-#include <memory>
-#include <string>
 
 template<typename It>
 inline spdlog::async_logger::async_logger(

include/spdlog/details/console_globals.h

@@ -6,7 +6,6 @@
 
 #include "spdlog/details/null_mutex.h"
 #include <cstdio>
-#include <mutex>
 
 namespace spdlog {
 namespace details {
@@ -40,7 +39,7 @@ struct console_stderr
 
 struct console_mutex
 {
-    using mutex_t = std::mutex;
+    using mutex_t = mutex;
     static mutex_t &mutex()
     {
         static mutex_t s_mutex;

include/spdlog/details/file_helper.h

@@ -13,12 +13,6 @@
 #include "../details/log_msg.h"
 #include "../details/os.h"
 
-#include <cerrno>
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <tuple>
 
 namespace spdlog {
 namespace details {

include/spdlog/details/fmt_helper.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "chrono"
 #include "spdlog/fmt/fmt.h"
 
 // Some fmt helpers to efficiently format and pad ints and strings
@@ -119,7 +118,7 @@ inline void pad6(size_t n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 template<typename ToDuration>
 inline ToDuration time_fraction(const log_clock::time_point &tp)
 {
-    using namespace std::chrono;
+    using namespace chrono;
     auto duration = tp.time_since_epoch();
     auto secs = duration_cast<seconds>(duration);
     return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);

include/spdlog/details/log_msg.h

@@ -8,8 +8,6 @@
 #include "spdlog/common.h"
 #include "spdlog/details/os.h"
 
-#include <string>
-#include <utility>
 
 namespace spdlog {
 namespace details {

include/spdlog/details/logger_impl.h

@@ -5,8 +5,6 @@
 
 #pragma once
 
-#include <memory>
-#include <string>
 
 // create logger with given name, sinks and the default pattern formatter
 // all other ctors will call this one
@@ -185,7 +183,7 @@ inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const
     try
     {
         {
-            std::lock_guard<std::mutex> lock(wstring_converter_mutex_);
+            lock_guard<mutex> lock(wstring_converter_mutex_);
             utf8_string = wstring_converter_.to_bytes(fmt);
         }
         log(lvl, utf8_string.c_str(), args...);

include/spdlog/details/mpmc_blocking_q.h

@@ -14,8 +14,6 @@
 
 #include "spdlog/details/circular_q.h"
 
-#include <condition_variable>
-#include <mutex>
 
 namespace spdlog {
 namespace details {
@@ -35,7 +33,7 @@ public:
     void enqueue(T &&item)
     {
         {
-            std::unique_lock<std::mutex> lock(queue_mutex_);
+            std::unique_lock<mutex> lock(queue_mutex_);
             pop_cv_.wait(lock, [this] { return !this->q_.full(); });
             q_.push_back(std::move(item));
         }
@@ -46,7 +44,7 @@ public:
     void enqueue_nowait(T &&item)
     {
         {
-            std::unique_lock<std::mutex> lock(queue_mutex_);
+            std::unique_lock<mutex> lock(queue_mutex_);
             q_.push_back(std::move(item));
         }
         push_cv_.notify_one();
@@ -54,10 +52,10 @@ public:
 
     // try to dequeue item. if no item found. wait upto timeout and try again
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    bool dequeue_for(T &popped_item, chrono::milliseconds wait_duration)
     {
         {
-            std::unique_lock<std::mutex> lock(queue_mutex_);
+            std::unique_lock<mutex> lock(queue_mutex_);
             if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
             {
                 return false;
@@ -75,7 +73,7 @@ public:
     // try to enqueue and block if no room left
     void enqueue(T &&item)
     {
-        std::unique_lock<std::mutex> lock(queue_mutex_);
+        unique_lock<mutex> lock(queue_mutex_);
         pop_cv_.wait(lock, [this] { return !this->q_.full(); });
         q_.push_back(std::move(item));
         push_cv_.notify_one();
@@ -84,16 +82,16 @@ public:
     // enqueue immediately. overrun oldest message in the queue if no room left.
     void enqueue_nowait(T &&item)
     {
-        std::unique_lock<std::mutex> lock(queue_mutex_);
+        unique_lock<mutex> lock(queue_mutex_);
         q_.push_back(std::move(item));
         push_cv_.notify_one();
     }
 
     // try to dequeue item. if no item found. wait upto timeout and try again
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    bool dequeue_for(T &popped_item, chrono::milliseconds wait_duration)
     {
-        std::unique_lock<std::mutex> lock(queue_mutex_);
+        unique_lock<mutex> lock(queue_mutex_);
         if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
         {
             return false;
@@ -106,9 +104,9 @@ public:
 #endif
 
 private:
-    std::mutex queue_mutex_;
+    mutex queue_mutex_;
-    std::condition_variable push_cv_;
+    condition_variable push_cv_;
-    std::condition_variable pop_cv_;
+    condition_variable pop_cv_;
     spdlog::details::circular_q<T> q_;
 };
 } // namespace details

include/spdlog/details/null_mutex.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-#include <atomic>
 // null, no cost dummy "mutex" and dummy "atomic" int
 
 namespace spdlog {

include/spdlog/details/os.h

@@ -7,7 +7,6 @@
 #include "../common.h"
 
 #include <algorithm>
-#include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -16,7 +15,6 @@
 #include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <thread>
 
 #ifdef _WIN32
 
@@ -63,8 +61,8 @@ inline spdlog::log_clock::time_point now()
 #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
     timespec ts;
     ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
-    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+    return chrono::time_point<log_clock, typename log_clock::duration>(
-        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+        chrono::duration_cast<typename log_clock::duration>(chrono::seconds(ts.tv_sec) + chrono::nanoseconds(ts.tv_nsec)));
 
 #else
     return log_clock::now();
@@ -341,7 +339,7 @@ inline size_t _thread_id()
     pthread_threadid_np(nullptr, &tid);
     return static_cast<size_t>(tid);
 #else // Default to standard C++11 (other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+    return static_cast<size_t>(std::hash<thread::id>()(std::this_thread::get_id()));
 #endif
 }
 
@@ -362,9 +360,13 @@ inline size_t thread_id()
 inline void sleep_for_millis(int milliseconds)
 {
 #if defined(_WIN32)
+# ifdef SPDLOG_USE_BOOST_THREAD
+    boost::this_thread::sleep_for(chrono::milliseconds(milliseconds));
+# else
     ::Sleep(milliseconds);
+# endif
 #else
-    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+    std::this_thread::sleep_for(chrono::milliseconds(milliseconds));
 #endif
 }
 

include/spdlog/details/pattern_formatter.h

@@ -11,15 +11,6 @@
 #include "spdlog/fmt/fmt.h"
 #include "spdlog/formatter.h"
 
-#include <array>
-#include <chrono>
-#include <ctime>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
 
 namespace spdlog {
 namespace details {
@@ -231,7 +222,7 @@ class e_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
-        auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
+        auto millis = fmt_helper::time_fraction<chrono::milliseconds>(msg.time);
         fmt_helper::pad3(static_cast<int>(millis.count()), dest);
     }
 };
@@ -241,7 +232,7 @@ class f_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
-        auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
+        auto micros = fmt_helper::time_fraction<chrono::microseconds>(msg.time);
         fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
     }
 };
@@ -251,7 +242,7 @@ class F_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
-        auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
+        auto ns = fmt_helper::time_fraction<chrono::nanoseconds>(msg.time);
         fmt::format_to(dest, "{:09}", ns.count());
     }
 };
@@ -262,7 +253,7 @@ class E_formatter SPDLOG_FINAL : public flag_formatter
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
         auto duration = msg.time.time_since_epoch();
-        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
+        auto seconds = chrono::duration_cast<chrono::seconds>(duration).count();
         fmt_helper::append_int(seconds, dest);
     }
 };
@@ -321,7 +312,7 @@ class T_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);
+    const chrono::seconds cache_refresh = chrono::seconds(5);
 
     z_formatter() = default;
     z_formatter(const z_formatter &) = delete;
@@ -354,7 +345,7 @@ public:
     }
 
 private:
-    log_clock::time_point last_update_{std::chrono::seconds(0)};
+    log_clock::time_point last_update_{chrono::seconds(0)};
 #ifdef _WIN32
     int offset_minutes_{0};
 
@@ -462,7 +453,7 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
     {
-        using namespace std::chrono;
+        using namespace chrono;
 #ifndef SPDLOG_NO_DATETIME
 
         // cache the date/time part for the next second.
@@ -522,7 +513,7 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
     }
 
 private:
-    std::chrono::seconds cache_timestamp_{0};
+    chrono::seconds cache_timestamp_{0};
     fmt::basic_memory_buffer<char, 128> cached_datetime_;
 };
 
@@ -553,7 +544,7 @@ public:
     void format(const details::log_msg &msg, fmt::memory_buffer &dest) override
     {
 #ifndef SPDLOG_NO_DATETIME
-        auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
+        auto secs = chrono::duration_cast<chrono::seconds>(msg.time.time_since_epoch());
         if (secs != last_log_secs_)
         {
             cached_tm_ = get_time_(msg);
@@ -573,7 +564,7 @@ private:
     std::string eol_;
     pattern_time_type pattern_time_type_;
     std::tm cached_tm_;
-    std::chrono::seconds last_log_secs_;
+    chrono::seconds last_log_secs_;
 
     std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
 

include/spdlog/details/periodic_worker.h

@@ -12,29 +12,25 @@
 //    creates the thread on construction.
 //    stops and joins the thread on destruction.
 
-#include <chrono>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <thread>
 namespace spdlog {
 namespace details {
 
+
 class periodic_worker
 {
 public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+    periodic_worker(const std::function<void()> &callback_fun, chrono::seconds interval)
     {
-        active_ = (interval > std::chrono::seconds::zero());
+        active_ = (interval > chrono::seconds::zero());
         if (!active_)
         {
             return;
         }
 
-        worker_thread_ = std::thread([this, callback_fun, interval]() {
+        worker_thread_ = thread([this, callback_fun, interval]() {
             for (;;)
             {
-                std::unique_lock<std::mutex> lock(this->mutex_);
+                unique_lock<mutex> lock(this->mutex_);
                 if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
                 {
                     return; // active_ == false, so exit this thread
@@ -53,7 +49,7 @@ public:
         if (worker_thread_.joinable())
         {
             {
-                std::lock_guard<std::mutex> lock(mutex_);
+                lock_guard<mutex> lock(mutex_);
                 active_ = false;
             }
             cv_.notify_one();
@@ -63,9 +59,9 @@ public:
 
 private:
     bool active_;
-    std::thread worker_thread_;
+    thread worker_thread_;
-    std::mutex mutex_;
+    mutex mutex_;
-    std::condition_variable cv_;
+    condition_variable cv_;
 };
 } // namespace details
 } // namespace spdlog

include/spdlog/details/registry.h

@@ -14,11 +14,6 @@
 #include "spdlog/details/periodic_worker.h"
 #include "spdlog/logger.h"
 
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
-#include <unordered_map>
 
 namespace spdlog {
 namespace details {
@@ -32,7 +27,7 @@ public:
 
     void register_logger(std::shared_ptr<logger> new_logger)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         auto logger_name = new_logger->name();
         throw_if_exists_(logger_name);
         loggers_[logger_name] = std::move(new_logger);
@@ -40,7 +35,7 @@ public:
 
     void register_and_init(std::shared_ptr<logger> new_logger)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         auto logger_name = new_logger->name();
         throw_if_exists_(logger_name);
 
@@ -61,27 +56,27 @@ public:
 
     std::shared_ptr<logger> get(const std::string &logger_name)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         auto found = loggers_.find(logger_name);
         return found == loggers_.end() ? nullptr : found->second;
     }
 
     void set_tp(std::shared_ptr<thread_pool> tp)
     {
-        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        lock_guard<recursive_mutex> lock(tp_mutex_);
         tp_ = std::move(tp);
     }
 
     std::shared_ptr<thread_pool> get_tp()
     {
-        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        lock_guard<recursive_mutex> lock(tp_mutex_);
         return tp_;
     }
 
     // Set global formatter. Each sink in each logger will get a clone of this object
     void set_formatter(std::unique_ptr<formatter> formatter)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         formatter_ = std::move(formatter);
         for (auto &l : loggers_)
         {
@@ -91,7 +86,7 @@ public:
 
     void set_level(level::level_enum log_level)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         for (auto &l : loggers_)
         {
             l.second->set_level(log_level);
@@ -101,7 +96,7 @@ public:
 
     void flush_on(level::level_enum log_level)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         for (auto &l : loggers_)
         {
             l.second->flush_on(log_level);
@@ -109,16 +104,16 @@ public:
         flush_level_ = log_level;
     }
 
-    void flush_every(std::chrono::seconds interval)
+    void flush_every(chrono::seconds interval)
     {
-        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        lock_guard<mutex> lock(flusher_mutex_);
         std::function<void()> clbk = std::bind(&registry::flush_all, this);
         periodic_flusher_.reset(new periodic_worker(clbk, interval));
     }
 
     void set_error_handler(log_err_handler handler)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         for (auto &l : loggers_)
         {
             l.second->set_error_handler(handler);
@@ -128,7 +123,7 @@ public:
 
     void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         for (auto &l : loggers_)
         {
             fun(l.second);
@@ -137,7 +132,7 @@ public:
 
     void flush_all()
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         for (auto &l : loggers_)
         {
             l.second->flush();
@@ -146,13 +141,13 @@ public:
 
     void drop(const std::string &logger_name)
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         loggers_.erase(logger_name);
     }
 
     void drop_all()
     {
-        std::lock_guard<std::mutex> lock(logger_map_mutex_);
+        lock_guard<mutex> lock(logger_map_mutex_);
         loggers_.clear();
     }
 
@@ -160,19 +155,19 @@ public:
     void shutdown()
     {
         {
-            std::lock_guard<std::mutex> lock(flusher_mutex_);
+            lock_guard<mutex> lock(flusher_mutex_);
             periodic_flusher_.reset();
         }
 
         drop_all();
 
         {
-            std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+            lock_guard<recursive_mutex> lock(tp_mutex_);
             tp_.reset();
         }
     }
 
-    std::recursive_mutex &tp_mutex()
+    recursive_mutex &tp_mutex()
     {
         return tp_mutex_;
     }
@@ -199,8 +194,8 @@ private:
         }
     }
 
-    std::mutex logger_map_mutex_, flusher_mutex_;
+    mutex logger_map_mutex_, flusher_mutex_;
-    std::recursive_mutex tp_mutex_;
+    recursive_mutex tp_mutex_;
     std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
     std::unique_ptr<formatter> formatter_;
     level::level_enum level_ = level::info;

include/spdlog/details/thread_pool.h

@@ -4,10 +4,8 @@
 #include "spdlog/details/mpmc_blocking_q.h"
 #include "spdlog/details/os.h"
 
-#include <chrono>
+// #include <memory>
-#include <memory>
+// #include <vector>
-#include <thread>
-#include <vector>
 
 namespace spdlog {
 namespace details {
@@ -160,7 +158,7 @@ public:
 private:
     q_type q_;
 
-    std::vector<std::thread> threads_;
+    std::vector<thread> threads_;
 
     void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
     {
@@ -185,7 +183,7 @@ private:
     bool process_next_msg_()
     {
         async_msg incoming_async_msg;
-        bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+        bool dequeued = q_.dequeue_for(incoming_async_msg, chrono::seconds(10));
         if (!dequeued)
         {
             return true;

include/spdlog/fmt/bundled/colors.h

@@ -1,257 +0,0 @@
-// Formatting library for C++ - the core API
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for rgb color output.
-
-#ifndef FMT_COLORS_H_
-#define FMT_COLORS_H_
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-// rgb is a struct for red, green and blue colors.
-// We use rgb as name because some editors will show it as color direct in the
-// editor.
-struct rgb
-{
-    FMT_CONSTEXPR_DECL rgb()
-        : r(0)
-        , g(0)
-        , b(0)
-    {
-    }
-    FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
-        : r(r_)
-        , g(g_)
-        , b(b_)
-    {
-    }
-    FMT_CONSTEXPR_DECL rgb(uint32_t hex)
-        : r((hex >> 16) & 0xFF)
-        , g((hex >> 8) & 0xFF)
-        , b((hex)&0xFF)
-    {
-    }
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-};
-
-namespace internal {
-
-FMT_CONSTEXPR inline void to_esc(uint8_t c, char out[], int offset)
-{
-    out[offset + 0] = static_cast<char>('0' + c / 100);
-    out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
-    out[offset + 2] = static_cast<char>('0' + c % 10);
-}
-
-} // namespace internal
-
-FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args)
-{
-    char escape_fd[] = "\x1b[38;2;000;000;000m";
-    static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m";
-    internal::to_esc(fd.r, escape_fd, 7);
-    internal::to_esc(fd.g, escape_fd, 11);
-    internal::to_esc(fd.b, escape_fd, 15);
-
-    std::fputs(escape_fd, stdout);
-    vprint(format, args);
-    std::fputs(RESET_COLOR, stdout);
-}
-
-FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args)
-{
-    char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
-    char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
-    static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m";
-    internal::to_esc(fd.r, escape_fd, 7);
-    internal::to_esc(fd.g, escape_fd, 11);
-    internal::to_esc(fd.b, escape_fd, 15);
-
-    internal::to_esc(bg.r, escape_bg, 7);
-    internal::to_esc(bg.g, escape_bg, 11);
-    internal::to_esc(bg.b, escape_bg, 15);
-
-    std::fputs(escape_fd, stdout);
-    std::fputs(escape_bg, stdout);
-    vprint(format, args);
-    std::fputs(RESET_COLOR, stdout);
-}
-
-template<typename... Args>
-inline void print_rgb(rgb fd, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, format_str, make_format_args(args...));
-}
-
-// rgb foreground color
-template<typename... Args>
-inline void print(rgb fd, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, format_str, make_format_args(args...));
-}
-
-// rgb foreground color and background color
-template<typename... Args>
-inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args)
-{
-    vprint_rgb(fd, bg, format_str, make_format_args(args...));
-}
-
-enum class color : uint32_t
-{
-    alice_blue = 0xF0F8FF,              // rgb(240,248,255)
-    antique_white = 0xFAEBD7,           // rgb(250,235,215)
-    aqua = 0x00FFFF,                    // rgb(0,255,255)
-    aquamarine = 0x7FFFD4,              // rgb(127,255,212)
-    azure = 0xF0FFFF,                   // rgb(240,255,255)
-    beige = 0xF5F5DC,                   // rgb(245,245,220)
-    bisque = 0xFFE4C4,                  // rgb(255,228,196)
-    black = 0x000000,                   // rgb(0,0,0)
-    blanched_almond = 0xFFEBCD,         // rgb(255,235,205)
-    blue = 0x0000FF,                    // rgb(0,0,255)
-    blue_violet = 0x8A2BE2,             // rgb(138,43,226)
-    brown = 0xA52A2A,                   // rgb(165,42,42)
-    burly_wood = 0xDEB887,              // rgb(222,184,135)
-    cadet_blue = 0x5F9EA0,              // rgb(95,158,160)
-    chartreuse = 0x7FFF00,              // rgb(127,255,0)
-    chocolate = 0xD2691E,               // rgb(210,105,30)
-    coral = 0xFF7F50,                   // rgb(255,127,80)
-    cornflower_blue = 0x6495ED,         // rgb(100,149,237)
-    cornsilk = 0xFFF8DC,                // rgb(255,248,220)
-    crimson = 0xDC143C,                 // rgb(220,20,60)
-    cyan = 0x00FFFF,                    // rgb(0,255,255)
-    dark_blue = 0x00008B,               // rgb(0,0,139)
-    dark_cyan = 0x008B8B,               // rgb(0,139,139)
-    dark_golden_rod = 0xB8860B,         // rgb(184,134,11)
-    dark_gray = 0xA9A9A9,               // rgb(169,169,169)
-    dark_green = 0x006400,              // rgb(0,100,0)
-    dark_khaki = 0xBDB76B,              // rgb(189,183,107)
-    dark_magenta = 0x8B008B,            // rgb(139,0,139)
-    dark_olive_green = 0x556B2F,        // rgb(85,107,47)
-    dark_orange = 0xFF8C00,             // rgb(255,140,0)
-    dark_orchid = 0x9932CC,             // rgb(153,50,204)
-    dark_red = 0x8B0000,                // rgb(139,0,0)
-    dark_salmon = 0xE9967A,             // rgb(233,150,122)
-    dark_sea_green = 0x8FBC8F,          // rgb(143,188,143)
-    dark_slate_blue = 0x483D8B,         // rgb(72,61,139)
-    dark_slate_gray = 0x2F4F4F,         // rgb(47,79,79)
-    dark_turquoise = 0x00CED1,          // rgb(0,206,209)
-    dark_violet = 0x9400D3,             // rgb(148,0,211)
-    deep_pink = 0xFF1493,               // rgb(255,20,147)
-    deep_sky_blue = 0x00BFFF,           // rgb(0,191,255)
-    dim_gray = 0x696969,                // rgb(105,105,105)
-    dodger_blue = 0x1E90FF,             // rgb(30,144,255)
-    fire_brick = 0xB22222,              // rgb(178,34,34)
-    floral_white = 0xFFFAF0,            // rgb(255,250,240)
-    forest_green = 0x228B22,            // rgb(34,139,34)
-    fuchsia = 0xFF00FF,                 // rgb(255,0,255)
-    gainsboro = 0xDCDCDC,               // rgb(220,220,220)
-    ghost_white = 0xF8F8FF,             // rgb(248,248,255)
-    gold = 0xFFD700,                    // rgb(255,215,0)
-    golden_rod = 0xDAA520,              // rgb(218,165,32)
-    gray = 0x808080,                    // rgb(128,128,128)
-    green = 0x008000,                   // rgb(0,128,0)
-    green_yellow = 0xADFF2F,            // rgb(173,255,47)
-    honey_dew = 0xF0FFF0,               // rgb(240,255,240)
-    hot_pink = 0xFF69B4,                // rgb(255,105,180)
-    indian_red = 0xCD5C5C,              // rgb(205,92,92)
-    indigo = 0x4B0082,                  // rgb(75,0,130)
-    ivory = 0xFFFFF0,                   // rgb(255,255,240)
-    khaki = 0xF0E68C,                   // rgb(240,230,140)
-    lavender = 0xE6E6FA,                // rgb(230,230,250)
-    lavender_blush = 0xFFF0F5,          // rgb(255,240,245)
-    lawn_green = 0x7CFC00,              // rgb(124,252,0)
-    lemon_chiffon = 0xFFFACD,           // rgb(255,250,205)
-    light_blue = 0xADD8E6,              // rgb(173,216,230)
-    light_coral = 0xF08080,             // rgb(240,128,128)
-    light_cyan = 0xE0FFFF,              // rgb(224,255,255)
-    light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
-    light_gray = 0xD3D3D3,              // rgb(211,211,211)
-    light_green = 0x90EE90,             // rgb(144,238,144)
-    light_pink = 0xFFB6C1,              // rgb(255,182,193)
-    light_salmon = 0xFFA07A,            // rgb(255,160,122)
-    light_sea_green = 0x20B2AA,         // rgb(32,178,170)
-    light_sky_blue = 0x87CEFA,          // rgb(135,206,250)
-    light_slate_gray = 0x778899,        // rgb(119,136,153)
-    light_steel_blue = 0xB0C4DE,        // rgb(176,196,222)
-    light_yellow = 0xFFFFE0,            // rgb(255,255,224)
-    lime = 0x00FF00,                    // rgb(0,255,0)
-    lime_green = 0x32CD32,              // rgb(50,205,50)
-    linen = 0xFAF0E6,                   // rgb(250,240,230)
-    magenta = 0xFF00FF,                 // rgb(255,0,255)
-    maroon = 0x800000,                  // rgb(128,0,0)
-    medium_aqua_marine = 0x66CDAA,      // rgb(102,205,170)
-    medium_blue = 0x0000CD,             // rgb(0,0,205)
-    medium_orchid = 0xBA55D3,           // rgb(186,85,211)
-    medium_purple = 0x9370DB,           // rgb(147,112,219)
-    medium_sea_green = 0x3CB371,        // rgb(60,179,113)
-    medium_slate_blue = 0x7B68EE,       // rgb(123,104,238)
-    medium_spring_green = 0x00FA9A,     // rgb(0,250,154)
-    medium_turquoise = 0x48D1CC,        // rgb(72,209,204)
-    medium_violet_red = 0xC71585,       // rgb(199,21,133)
-    midnight_blue = 0x191970,           // rgb(25,25,112)
-    mint_cream = 0xF5FFFA,              // rgb(245,255,250)
-    misty_rose = 0xFFE4E1,              // rgb(255,228,225)
-    moccasin = 0xFFE4B5,                // rgb(255,228,181)
-    navajo_white = 0xFFDEAD,            // rgb(255,222,173)
-    navy = 0x000080,                    // rgb(0,0,128)
-    old_lace = 0xFDF5E6,                // rgb(253,245,230)
-    olive = 0x808000,                   // rgb(128,128,0)
-    olive_drab = 0x6B8E23,              // rgb(107,142,35)
-    orange = 0xFFA500,                  // rgb(255,165,0)
-    orange_red = 0xFF4500,              // rgb(255,69,0)
-    orchid = 0xDA70D6,                  // rgb(218,112,214)
-    pale_golden_rod = 0xEEE8AA,         // rgb(238,232,170)
-    pale_green = 0x98FB98,              // rgb(152,251,152)
-    pale_turquoise = 0xAFEEEE,          // rgb(175,238,238)
-    pale_violet_red = 0xDB7093,         // rgb(219,112,147)
-    papaya_whip = 0xFFEFD5,             // rgb(255,239,213)
-    peach_puff = 0xFFDAB9,              // rgb(255,218,185)
-    peru = 0xCD853F,                    // rgb(205,133,63)
-    pink = 0xFFC0CB,                    // rgb(255,192,203)
-    plum = 0xDDA0DD,                    // rgb(221,160,221)
-    powder_blue = 0xB0E0E6,             // rgb(176,224,230)
-    purple = 0x800080,                  // rgb(128,0,128)
-    rebecca_purple = 0x663399,          // rgb(102,51,153)
-    red = 0xFF0000,                     // rgb(255,0,0)
-    rosy_brown = 0xBC8F8F,              // rgb(188,143,143)
-    royal_blue = 0x4169E1,              // rgb(65,105,225)
-    saddle_brown = 0x8B4513,            // rgb(139,69,19)
-    salmon = 0xFA8072,                  // rgb(250,128,114)
-    sandy_brown = 0xF4A460,             // rgb(244,164,96)
-    sea_green = 0x2E8B57,               // rgb(46,139,87)
-    sea_shell = 0xFFF5EE,               // rgb(255,245,238)
-    sienna = 0xA0522D,                  // rgb(160,82,45)
-    silver = 0xC0C0C0,                  // rgb(192,192,192)
-    sky_blue = 0x87CEEB,                // rgb(135,206,235)
-    slate_blue = 0x6A5ACD,              // rgb(106,90,205)
-    slate_gray = 0x708090,              // rgb(112,128,144)
-    snow = 0xFFFAFA,                    // rgb(255,250,250)
-    spring_green = 0x00FF7F,            // rgb(0,255,127)
-    steel_blue = 0x4682B4,              // rgb(70,130,180)
-    tan = 0xD2B48C,                     // rgb(210,180,140)
-    teal = 0x008080,                    // rgb(0,128,128)
-    thistle = 0xD8BFD8,                 // rgb(216,191,216)
-    tomato = 0xFF6347,                  // rgb(255,99,71)
-    turquoise = 0x40E0D0,               // rgb(64,224,208)
-    violet = 0xEE82EE,                  // rgb(238,130,238)
-    wheat = 0xF5DEB3,                   // rgb(245,222,179)
-    white = 0xFFFFFF,                   // rgb(255,255,255)
-    white_smoke = 0xF5F5F5,             // rgb(245,245,245)
-    yellow = 0xFFFF00,                  // rgb(255,255,0)
-    yellow_green = 0x9ACD32,            // rgb(154,205,50)
-};                                      // enum class colors
-
-FMT_END_NAMESPACE
-
-#endif // FMT_COLORS_H_

include/spdlog/fmt/bundled/format-inl.h

@@ -21,47 +21,45 @@
 #include <locale>
 
 #if defined(_WIN32) && defined(__MINGW32__)
-#include <cstring>
+# include <cstring>
 #endif
 
 #if FMT_USE_WINDOWS_H
-#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
+# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#define WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
-#endif
+# endif
-#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#include <windows.h>
+#  include <windows.h>
-#else
+# else
-#define NOMINMAX
+#  define NOMINMAX
-#include <windows.h>
+#  include <windows.h>
-#undef NOMINMAX
+#  undef NOMINMAX
-#endif
+# endif
 #endif
 
 #if FMT_EXCEPTIONS
-#define FMT_TRY try
+# define FMT_TRY try
-#define FMT_CATCH(x) catch (x)
+# define FMT_CATCH(x) catch (x)
 #else
-#define FMT_TRY if (true)
+# define FMT_TRY if (true)
-#define FMT_CATCH(x) if (false)
+# define FMT_CATCH(x) if (false)
 #endif
 
 #ifdef _MSC_VER
-#pragma warning(push)
+# pragma warning(push)
-#pragma warning(disable : 4127) // conditional expression is constant
+# pragma warning(disable: 4127)  // conditional expression is constant
-#pragma warning(disable : 4702) // unreachable code
+# pragma warning(disable: 4702)  // unreachable code
 // Disable deprecation warning for strerror. The latter is not called but
 // MSVC fails to detect it.
-#pragma warning(disable : 4996)
+# pragma warning(disable: 4996)
 #endif
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char *, ...)
+inline fmt::internal::null<> strerror_r(int, char *, ...) {
-{
   return fmt::internal::null<>();
 }
-inline fmt::internal::null<> strerror_s(char *, std::size_t, ...)
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
-{
   return fmt::internal::null<>();
 }
 
@@ -70,23 +68,22 @@ FMT_BEGIN_NAMESPACE
 namespace {
 
 #ifndef _MSC_VER
-#define FMT_SNPRINTF snprintf
+# define FMT_SNPRINTF snprintf
 #else  // _MSC_VER
-inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...)
+inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
-{
   va_list args;
   va_start(args, format);
   int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
   va_end(args);
   return result;
 }
-#define FMT_SNPRINTF fmt_snprintf
+# define FMT_SNPRINTF fmt_snprintf
 #endif  // _MSC_VER
 
 #if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-#define FMT_SWPRINTF snwprintf
+# define FMT_SWPRINTF snwprintf
 #else
-#define FMT_SWPRINTF swprintf
+# define FMT_SWPRINTF swprintf
 #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
 
 typedef void (*FormatFunc)(internal::buffer &, int, string_view);
@@ -100,12 +97,11 @@ typedef void (*FormatFunc)(internal::buffer &, int, string_view);
 //   ERANGE - buffer is not large enough to store the error message
 //   other  - failure
 // Buffer should be at least of size 1.
-int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT
+int safe_strerror(
-{
+    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
   FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
 
-    class dispatcher
+  class dispatcher {
-    {
    private:
     int error_code_;
     char *&buffer_;
@@ -115,15 +111,13 @@ int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NO
     void operator=(const dispatcher &) {}
 
     // Handle the result of XSI-compliant version of strerror_r.
-        int handle(int result)
+    int handle(int result) {
-        {
       // glibc versions before 2.13 return result in errno.
       return result == -1 ? errno : result;
     }
 
     // Handle the result of GNU-specific version of strerror_r.
-        int handle(char *message)
+    int handle(char *message) {
-        {
       // If the buffer is full then the message is probably truncated.
       if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
         return ERANGE;
@@ -132,21 +126,19 @@ int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NO
     }
 
     // Handle the case when strerror_r is not available.
-        int handle(internal::null<>)
+    int handle(internal::null<>) {
-        {
       return fallback(strerror_s(buffer_, buffer_size_, error_code_));
     }
 
     // Fallback to strerror_s when strerror_r is not available.
-        int fallback(int result)
+    int fallback(int result) {
-        {
       // If the buffer is full then the message is probably truncated.
-            return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE : result;
+      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
+            ERANGE : result;
     }
 
     // Fallback to strerror if strerror_r and strerror_s are not available.
-        int fallback(internal::null<>)
+    int fallback(internal::null<>) {
-        {
       errno = 0;
       buffer_ = strerror(error_code_);
       return errno;
@@ -154,22 +146,17 @@ int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NO
 
    public:
     dispatcher(int err_code, char *&buf, std::size_t buf_size)
-            : error_code_(err_code)
+      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-            , buffer_(buf)
-            , buffer_size_(buf_size)
-        {
-        }
 
-        int run()
+    int run() {
-        {
       return handle(strerror_r(error_code_, buffer_, buffer_size_));
     }
   };
   return dispatcher(error_code, buffer, buffer_size).run();
 }
 
-void format_error_code(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
+void format_error_code(internal::buffer &out, int error_code,
-{
+                       string_view message) FMT_NOEXCEPT {
   // Report error code making sure that the output fits into
   // inline_buffer_size to avoid dynamic memory allocation and potential
   // bad_alloc.
@@ -180,15 +167,13 @@ void format_error_code(internal::buffer &out, int error_code, string_view messag
   std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
   typedef internal::int_traits<int>::main_type main_type;
   main_type abs_value = static_cast<main_type>(error_code);
-    if (internal::is_negative(error_code))
+  if (internal::is_negative(error_code)) {
-    {
     abs_value = 0 - abs_value;
     ++error_code_size;
   }
   error_code_size += internal::count_digits(abs_value);
   writer w(out);
-    if (message.size() <= inline_buffer_size - error_code_size)
+  if (message.size() <= inline_buffer_size - error_code_size) {
-    {
     w.write(message);
     w.write(SEP);
   }
@@ -197,8 +182,8 @@ void format_error_code(internal::buffer &out, int error_code, string_view messag
   assert(out.size() <= inline_buffer_size);
 }
 
-void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT
+void report_error(FormatFunc func, int error_code,
-{
+                  string_view message) FMT_NOEXCEPT {
   memory_buffer full_message;
   func(full_message, error_code, message);
   // Use Writer::data instead of Writer::c_str to avoid potential memory
@@ -208,31 +193,33 @@ void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEX
 }
 }  // namespace
 
-class locale
+class locale {
-{
+ private:
-private:
   std::locale locale_;
 
-public:
+ public:
-    explicit locale(std::locale loc = std::locale())
+  explicit locale(std::locale loc = std::locale()) : locale_(loc) {}
-        : locale_(loc)
+  std::locale get() { return locale_; }
-    {
-    }
-    std::locale get()
-    {
-        return locale_;
-    }
 };
 
-template<typename Char>
+FMT_FUNC size_t internal::count_code_points(u8string_view s) {
-FMT_FUNC Char internal::thousands_sep(locale_provider *lp)
+  const char8_t *data = s.data();
-{
+  int num_code_points = 0;
+  for (size_t i = 0, size = s.size(); i != size; ++i) {
+    if ((data[i].value & 0xc0) != 0x80)
+      ++num_code_points;
+  }
+  return num_code_points;
+}
+
+template <typename Char>
+FMT_FUNC Char internal::thousands_sep(locale_provider *lp) {
   std::locale loc = lp ? lp->locale().get() : std::locale();
   return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
 }
 
-FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args)
+FMT_FUNC void system_error::init(
-{
+    int err_code, string_view format_str, format_args args) {
   error_code_ = err_code;
   memory_buffer buffer;
   format_system_error(buffer, err_code, vformat(format_str, args));
@@ -241,69 +228,101 @@ FMT_FUNC void system_error::init(int err_code, string_view format_str, format_ar
 }
 
 namespace internal {
-template<typename T>
+template <typename T>
-int char_traits<char>::format_float(char *buffer, std::size_t size, const char *format, int precision, T value)
+int char_traits<char>::format_float(
-{
+    char *buffer, std::size_t size, const char *format, int precision, T value) {
-    return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value);
+  return precision < 0 ?
-}
+      FMT_SNPRINTF(buffer, size, format, value) :
-
+      FMT_SNPRINTF(buffer, size, format, precision, value);
-template<typename T>
+}
-int char_traits<wchar_t>::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value)
+
-{
+template <typename T>
-    return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value);
+int char_traits<wchar_t>::format_float(
-}
+    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision,
-
+    T value) {
-template<typename T>
+  return precision < 0 ?
-const char basic_data<T>::DIGITS[] = "0001020304050607080910111213141516171819"
+      FMT_SWPRINTF(buffer, size, format, value) :
+      FMT_SWPRINTF(buffer, size, format, precision, value);
+}
+
+template <typename T>
+const char basic_data<T>::DIGITS[] =
+    "0001020304050607080910111213141516171819"
     "2021222324252627282930313233343536373839"
     "4041424344454647484950515253545556575859"
     "6061626364656667686970717273747576777879"
     "8081828384858687888990919293949596979899";
 
 #define FMT_POWERS_OF_10(factor) \
-    factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, factor * 1000000, factor * 10000000, factor * 100000000,    \
+  factor * 10, \
+  factor * 100, \
+  factor * 1000, \
+  factor * 10000, \
+  factor * 100000, \
+  factor * 1000000, \
+  factor * 10000000, \
+  factor * 100000000, \
   factor * 1000000000
 
-template<typename T>
+template <typename T>
-const uint32_t basic_data<T>::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)};
+const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
+  0, FMT_POWERS_OF_10(1)
+};
 
-template<typename T>
+template <typename T>
-const uint64_t basic_data<T>::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+const uint64_t basic_data<T>::POWERS_OF_10_64[] = {
+  0,
+  FMT_POWERS_OF_10(1),
+  FMT_POWERS_OF_10(1000000000ull),
+  10000000000000000000ull
+};
 
 // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
 // These are generated by support/compute-powers.py.
-template<typename T>
+template <typename T>
-const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
-    0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c,
+  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
-    0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+  0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
-    0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b,
+  0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-    0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
-    0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94,
+  0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
-    0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+  0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-    0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000,
+  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
-    0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+  0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
-    0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea,
+  0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-    0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
-    0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5,
+  0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
-    0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+  0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-    0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d,
+  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
-    0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b};
+  0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
+  0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+  0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
+  0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+  0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
+  0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b
+};
 
 // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
 // to significands above.
-template<typename T>
+template <typename T>
-const int16_t basic_data<T>::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+const int16_t basic_data<T>::POW10_EXPONENTS[] = {
-    -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316,
+  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,  -954,
-    -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375,
+   -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,
-    402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
+   -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396,  -369,
-
+   -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103,   -77,
-template<typename T>
+    -50,   -24,     3,    30,    56,    83,   109,   136,   162,   189,   216,
-const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,   508,
-template<typename T>
+    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,   800,
-const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
-
+};
-FMT_FUNC fp operator*(fp x, fp y)
+
-{
+template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+
+FMT_FUNC fp operator*(fp x, fp y) {
   // Multiply 32-bit parts of significands.
   uint64_t mask = (1ULL << 32) - 1;
   uint64_t a = x.f >> 32, b = x.f & mask;
@@ -314,14 +333,13 @@ FMT_FUNC fp operator*(fp x, fp y)
   return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
 }
 
-FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
+FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
-{
   const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-    int index = static_cast<int>(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
+  int index = static_cast<int>(std::ceil(
+        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
   // Decimal exponent of the first (smallest) cached power of 10.
   const int first_dec_exp = -348;
-    // Difference between two consecutive decimal exponents in cached powers of
+  // Difference between two consecutive decimal exponents in cached powers of 10.
-    // 10.
   const int dec_exp_step = 8;
   index = (index - first_dec_exp - 1) / dec_exp_step + 1;
   pow10_exponent = first_dec_exp + index * dec_exp_step;
@@ -331,64 +349,63 @@ FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
 
 #if FMT_USE_WINDOWS_H
 
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s)
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
-{
   static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
   if (s.size() > INT_MAX)
     FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
   int s_size = static_cast<int>(s.size());
-    if (s_size == 0)
+  if (s_size == 0) {
-    {
     // MultiByteToWideChar does not support zero length, handle separately.
     buffer_.resize(1);
     buffer_[0] = 0;
     return;
   }
 
-    int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
+  int length = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
   if (length == 0)
     FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_.resize(length + 1);
-    length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
+  length = MultiByteToWideChar(
+    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
   if (length == 0)
     FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
   buffer_[length] = 0;
 }
 
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s)
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
-{
+  if (int error_code = convert(s)) {
-    if (int error_code = convert(s))
+    FMT_THROW(windows_error(error_code,
-    {
+        "cannot convert string from UTF-16 to UTF-8"));
-        FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8"));
   }
 }
 
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s)
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-{
   if (s.size() > INT_MAX)
     return ERROR_INVALID_PARAMETER;
   int s_size = static_cast<int>(s.size());
-    if (s_size == 0)
+  if (s_size == 0) {
-    {
     // WideCharToMultiByte does not support zero length, handle separately.
     buffer_.resize(1);
     buffer_[0] = 0;
     return 0;
   }
 
-    int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
+  int length = WideCharToMultiByte(
+        CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
   if (length == 0)
     return GetLastError();
   buffer_.resize(length + 1);
-    length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
+  length = WideCharToMultiByte(
+    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
   if (length == 0)
     return GetLastError();
   buffer_[length] = 0;
   return 0;
 }
 
-FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args)
+FMT_FUNC void windows_error::init(
-{
+    int err_code, string_view format_str, format_args args) {
   error_code_ = err_code;
   memory_buffer buffer;
   internal::format_windows_error(buffer, err_code, vformat(format_str, args));
@@ -396,22 +413,20 @@ FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_a
   base = std::runtime_error(to_string(buffer));
 }
 
-FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
+FMT_FUNC void internal::format_windows_error(
-{
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-    FMT_TRY
+  FMT_TRY {
-    {
     wmemory_buffer buf;
     buf.resize(inline_buffer_size);
-        for (;;)
+    for (;;) {
-        {
       wchar_t *system_message = &buf[0];
-            int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code,
+      int result = FormatMessageW(
-                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-            if (result != 0)
+          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            {
+          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+      if (result != 0) {
         utf16_to_utf8 utf8_message;
-                if (utf8_message.convert(system_message) == ERROR_SUCCESS)
+        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
-                {
           writer w(out);
           w.write(message);
           w.write(": ");
@@ -424,25 +439,21 @@ FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_co
         break;  // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
-    }
+  } FMT_CATCH(...) {}
-    FMT_CATCH(...) {}
   format_error_code(out, error_code, message);
 }
 
 #endif  // FMT_USE_WINDOWS_H
 
-FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
+FMT_FUNC void format_system_error(
-{
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-    FMT_TRY
+  FMT_TRY {
-    {
     memory_buffer buf;
     buf.resize(inline_buffer_size);
-        for (;;)
+    for (;;) {
-        {
       char *system_message = &buf[0];
       int result = safe_strerror(error_code, system_message, buf.size());
-            if (result == 0)
+      if (result == 0) {
-            {
         writer w(out);
         w.write(message);
         w.write(": ");
@@ -453,61 +464,53 @@ FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_
         break;  // Can't get error message, report error code instead.
       buf.resize(buf.size() * 2);
     }
-    }
+  } FMT_CATCH(...) {}
-    FMT_CATCH(...) {}
   format_error_code(out, error_code, message);
 }
 
-template<typename Char>
+template <typename Char>
-void basic_fixed_buffer<Char>::grow(std::size_t)
+void basic_fixed_buffer<Char>::grow(std::size_t) {
-{
   FMT_THROW(std::runtime_error("buffer overflow"));
 }
 
-FMT_FUNC void internal::error_handler::on_error(const char *message)
+FMT_FUNC void internal::error_handler::on_error(const char *message) {
-{
   FMT_THROW(format_error(message));
 }
 
-FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+FMT_FUNC void report_system_error(
-{
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
   report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+FMT_FUNC void report_windows_error(
-{
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
   report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
-{
   memory_buffer buffer;
   vformat_to(buffer, format_str, args);
   std::fwrite(buffer.data(), 1, buffer.size(), f);
 }
 
-FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args)
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
-{
   wmemory_buffer buffer;
   vformat_to(buffer, format_str, args);
   std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
 }
 
-FMT_FUNC void vprint(string_view format_str, format_args args)
+FMT_FUNC void vprint(string_view format_str, format_args args) {
-{
   vprint(stdout, format_str, args);
 }
 
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args)
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
-{
   vprint(stdout, format_str, args);
 }
 
 #ifndef FMT_EXTENDED_COLORS
-FMT_FUNC void vprint_colored(color c, string_view format, format_args args)
+FMT_FUNC void vprint_colored(color c, string_view format, format_args args) {
-{
   char escape[] = "\x1b[30m";
   escape[3] = static_cast<char>('0' + c);
   std::fputs(escape, stdout);
@@ -515,8 +518,7 @@ FMT_FUNC void vprint_colored(color c, string_view format, format_args args)
   std::fputs(internal::data::RESET_COLOR, stdout);
 }
 
-FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args)
+FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) {
-{
   wchar_t escape[] = L"\x1b[30m";
   escape[3] = static_cast<wchar_t>('0' + c);
   std::fputws(escape, stdout);
@@ -525,16 +527,14 @@ FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args)
 }
 #else
 namespace internal {
-FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset)
+FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) {
-{
   out[offset + 0] = static_cast<char>('0' + c / 100);
   out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
   out[offset + 2] = static_cast<char>('0' + c % 10);
 }
 } // namespace internal
 
-FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args)
+FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) {
-{
   char escape_fd[] = "\x1b[38;2;000;000;000m";
   internal::to_esc(fd.r, escape_fd, 7);
   internal::to_esc(fd.g, escape_fd, 11);
@@ -545,8 +545,7 @@ FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args)
   std::fputs(internal::data::RESET_COLOR, stdout);
 }
 
-FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args)
+FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) {
-{
   char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
   char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
   internal::to_esc(fd.r, escape_fd, 7);
@@ -564,15 +563,12 @@ FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args)
 }
 #endif
 
-FMT_FUNC locale locale_provider::locale()
+FMT_FUNC locale locale_provider::locale() { return fmt::locale(); }
-{
-    return fmt::locale();
-}
 
 FMT_END_NAMESPACE
 
 #ifdef _MSC_VER
-#pragma warning(pop)
+# pragma warning(pop)
 #endif
 
 #endif  // FMT_FORMAT_INL_H_

include/spdlog/fmt/bundled/locale.h

@@ -1,27 +0,0 @@
-// Formatting library for C++ - locale support
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "format.h"
-#include <locale>
-
-namespace fmt {
-class locale
-{
-private:
-    std::locale locale_;
-
-public:
-    explicit locale(std::locale loc = std::locale())
-        : locale_(loc)
-    {
-    }
-    std::locale get()
-    {
-        return locale_;
-    }
-};
-} // namespace fmt

include/spdlog/fmt/bundled/ostream.h

@@ -14,22 +14,18 @@
 FMT_BEGIN_NAMESPACE
 namespace internal {
 
-template<class Char>
+template <class Char>
-class formatbuf : public std::basic_streambuf<Char>
+class formatbuf : public std::basic_streambuf<Char> {
-{
+ private:
-private:
   typedef typename std::basic_streambuf<Char>::int_type int_type;
   typedef typename std::basic_streambuf<Char>::traits_type traits_type;
 
   basic_buffer<Char> &buffer_;
 
-public:
+ public:
-    formatbuf(basic_buffer<Char> &buffer)
+  formatbuf(basic_buffer<Char> &buffer) : buffer_(buffer) {}
-        : buffer_(buffer)
-    {
-    }
 
-protected:
+ protected:
   // The put-area is actually always empty. This makes the implementation
   // simpler and has the advantage that the streambuf and the buffer are always
   // in sync and sputc never writes into uninitialized memory. The obvious
@@ -37,69 +33,62 @@ protected:
   // to overflow. There is no disadvantage here for sputn since this always
   // results in a call to xsputn.
 
-    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    {
     if (!traits_type::eq_int_type(ch, traits_type::eof()))
       buffer_.push_back(static_cast<Char>(ch));
     return ch;
   }
 
-    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
+  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
-    {
     buffer_.append(s, s + count);
     return count;
   }
 };
 
-template<typename Char>
+template <typename Char>
-struct test_stream : std::basic_ostream<Char>
+struct test_stream : std::basic_ostream<Char> {
-{
+ private:
-private:
   struct null;
   // Hide all operator<< from std::basic_ostream<Char>.
   void operator<<(null);
 };
 
-// Checks if T has a user-defined operator<< (e.g. not a member of
+// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
-// std::ostream).
+template <typename T, typename Char>
-template<typename T, typename Char>
+class is_streamable {
-class is_streamable
+ private:
-{
+  template <typename U>
-private:
+  static decltype(
-    template<typename U>
+    internal::declval<test_stream<Char>&>()
-    static decltype(internal::declval<test_stream<Char> &>() << internal::declval<U>(), std::true_type()) test(int);
+      << internal::declval<U>(), std::true_type()) test(int);
 
-    template<typename>
+  template <typename>
   static std::false_type test(...);
 
   typedef decltype(test<T>(0)) result;
 
-public:
+ public:
-    // std::string operator<< is not considered user-defined because we handle
+  static const bool value = result::value;
-    // strings
-    // specially.
-    static const bool value = result::value && !std::is_same<T, std::string>::value;
 };
 
 // Disable conversion to int if T has an overloaded operator<< which is a free
 // function (not a member of std::ostream).
-template<typename T, typename Char>
+template <typename T, typename Char>
-class convert_to_int<T, Char, true>
+class convert_to_int<T, Char, true> {
-{
+ public:
-public:
+  static const bool value =
-    static const bool value = convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+    convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
 };
 
 // Write the content of buf to os.
-template<typename Char>
+template <typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
+void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
-{
   const Char *data = buf.data();
   typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
   UnsignedStreamSize size = buf.size();
-    UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
+  UnsignedStreamSize max_size =
-    do
+      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-    {
+  do {
     UnsignedStreamSize n = size <= max_size ? size : max_size;
     os.write(data, static_cast<std::streamsize>(n));
     data += n;
@@ -107,43 +96,38 @@ void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
   } while (size != 0);
 }
 
-template<typename Char, typename T>
+template <typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value)
+void format_value(basic_buffer<Char> &buffer, const T &value) {
-{
   internal::formatbuf<Char> format_buf(buffer);
   std::basic_ostream<Char> output(&format_buf);
   output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
   output << value;
   buffer.resize(buffer.size());
 }
-
-// Disable builtin formatting of enums and use operator<< instead.
-template<typename T>
-struct format_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type
-{
-};
 }  // namespace internal
 
 // Formats an object of type T that has an overloaded ostream operator<<.
-template<typename T, typename Char>
+template <typename T, typename Char>
-struct formatter<T, Char, typename std::enable_if<internal::is_streamable<T, Char>::value>::type> : formatter<basic_string_view<Char>, Char>
+struct formatter<T, Char,
-{
+    typename std::enable_if<
-
+      internal::is_streamable<T, Char>::value &&
-    template<typename Context>
+      !internal::format_type<
-    auto format(const T &value, Context &ctx) -> decltype(ctx.out())
+        typename buffer_context<Char>::type, T>::value>::type>
-    {
+    : formatter<basic_string_view<Char>, Char> {
+
+  template <typename Context>
+  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
     basic_memory_buffer<Char> buffer;
     internal::format_value(buffer, value);
     basic_string_view<Char> str(buffer.data(), buffer.size());
-        formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
-        return ctx.out();
   }
 };
 
-template<typename Char>
+template <typename Char>
-inline void vprint(
+inline void vprint(std::basic_ostream<Char> &os,
-    std::basic_ostream<Char> &os, basic_string_view<Char> format_str, basic_format_args<typename buffer_context<Char>::type> args)
+                   basic_string_view<Char> format_str,
-{
+                   basic_format_args<typename buffer_context<Char>::type> args) {
   basic_memory_buffer<Char> buffer;
   vformat_to(buffer, format_str, args);
   internal::write(os, buffer);
@@ -157,15 +141,15 @@ inline void vprint(
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-template<typename... Args>
+template <typename... Args>
-inline void print(std::ostream &os, string_view format_str, const Args &... args)
+inline void print(std::ostream &os, string_view format_str,
-{
+                  const Args & ... args) {
   vprint<char>(os, format_str, make_format_args<format_context>(args...));
 }
 
-template<typename... Args>
+template <typename... Args>
-inline void print(std::wostream &os, wstring_view format_str, const Args &... args)
+inline void print(std::wostream &os, wstring_view format_str,
-{
+                  const Args & ... args) {
   vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
 }
 FMT_END_NAMESPACE

include/spdlog/fmt/bundled/posix.h

@@ -10,7 +10,7 @@
 
 #if defined(__MINGW32__) || defined(__CYGWIN__)
 // Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-#undef __STRICT_ANSI__
+# undef __STRICT_ANSI__
 #endif
 
 #include <errno.h>
@@ -22,43 +22,42 @@
 #include <cstddef>
 
 #if defined __APPLE__ || defined(__FreeBSD__)
-#include <xlocale.h> // for LC_NUMERIC_MASK on OS X
+# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
 #endif
 
 #include "format.h"
 
 #ifndef FMT_POSIX
-#if defined(_WIN32) && !defined(__MINGW32__)
+# if defined(_WIN32) && !defined(__MINGW32__)
 // Fix warnings about deprecated symbols.
-#define FMT_POSIX(call) _##call
+#  define FMT_POSIX(call) _##call
-#else
+# else
-#define FMT_POSIX(call) call
+#  define FMT_POSIX(call) call
-#endif
+# endif
 #endif
 
 // Calls to system functions are wrapped in FMT_SYSTEM for testability.
 #ifdef FMT_SYSTEM
-#define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
-#define FMT_SYSTEM(call) call
+# define FMT_SYSTEM(call) call
-#ifdef _WIN32
+# ifdef _WIN32
 // Fix warnings about deprecated symbols.
-#define FMT_POSIX_CALL(call) ::_##call
+#  define FMT_POSIX_CALL(call) ::_##call
-#else
+# else
-#define FMT_POSIX_CALL(call) ::call
+#  define FMT_POSIX_CALL(call) ::call
-#endif
+# endif
 #endif
 
 // Retries the expression while it evaluates to error_result and errno
 // equals to EINTR.
 #ifndef _WIN32
-#define FMT_RETRY_VAL(result, expression, error_result)                                                                                    \
+# define FMT_RETRY_VAL(result, expression, error_result) \
-    do                                                                                                                                     \
+  do { \
-    {                                                                                                                                      \
     result = (expression); \
   } while (result == error_result && errno == EINTR)
 #else
-#define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
 #endif
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
@@ -90,140 +89,72 @@ FMT_BEGIN_NAMESPACE
     format(std::string("{}"), 42);
   \endrst
  */
-template<typename Char>
+template <typename Char>
-class basic_cstring_view
+class basic_cstring_view {
-{
+ private:
-private:
   const Char *data_;
 
-public:
+ public:
   /** Constructs a string reference object from a C string. */
-    basic_cstring_view(const Char *s)
+  basic_cstring_view(const Char *s) : data_(s) {}
-        : data_(s)
-    {
-    }
 
   /**
     \rst
     Constructs a string reference from an ``std::string`` object.
     \endrst
    */
-    basic_cstring_view(const std::basic_string<Char> &s)
+  basic_cstring_view(const std::basic_string<Char> &s) : data_(s.c_str()) {}
-        : data_(s.c_str())
-    {
-    }
 
   /** Returns the pointer to a C string. */
-    const Char *c_str() const
+  const Char *c_str() const { return data_; }
-    {
-        return data_;
-    }
 };
 
 typedef basic_cstring_view<char> cstring_view;
 typedef basic_cstring_view<wchar_t> wcstring_view;
 
 // An error code.
-class error_code
+class error_code {
-{
+ private:
-private:
   int value_;
 
-public:
+ public:
   explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
 
-    int get() const FMT_NOEXCEPT
+  int get() const FMT_NOEXCEPT { return value_; }
-    {
-        return value_;
-    }
 };
 
 // A buffered file.
-class buffered_file
+class buffered_file {
-{
+ private:
-private:
   FILE *file_;
 
   friend class file;
 
-    explicit buffered_file(FILE *f)
+  explicit buffered_file(FILE *f) : file_(f) {}
-        : file_(f)
-    {
-    }
 
-public:
+ public:
   // Constructs a buffered_file object which doesn't represent any file.
   buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
 
   // Destroys the object closing the file it represents if any.
   FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT;
 
-#if !FMT_USE_RVALUE_REFERENCES
+ private:
-    // Emulate a move constructor and a move assignment operator if rvalue
+  buffered_file(const buffered_file &) = delete;
-    // references are not supported.
+  void operator=(const buffered_file &) = delete;
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        FILE *file;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-    buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
-
-    // A "move constructor" for moving from an lvalue.
-    buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_)
-    {
-        f.file_ = FMT_NULL;
-    }
-
-    // A "move assignment operator" for moving from a temporary.
-    buffered_file &operator=(Proxy p)
-    {
-        close();
-        file_ = p.file;
-        return *this;
-    }
 
-    // A "move assignment operator" for moving from an lvalue.
-    buffered_file &operator=(buffered_file &other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = FMT_NULL;
-        return *this;
-    }
 
-    // Returns a proxy object for moving from a temporary:
+ public:
-    //   buffered_file file = buffered_file(...);
+  buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {file_};
-        file_ = FMT_NULL;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
-
-public:
-    buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_)
-    {
     other.file_ = FMT_NULL;
   }
 
-    buffered_file &operator=(buffered_file &&other)
+  buffered_file& operator=(buffered_file &&other) {
-    {
     close();
     file_ = other.file_;
     other.file_ = FMT_NULL;
     return *this;
   }
-#endif
 
   // Opens a file.
   FMT_API buffered_file(cstring_view filename, cstring_view mode);
@@ -232,23 +163,18 @@ public:
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
+  FILE *get() const FMT_NOEXCEPT { return file_; }
-    {
-        return file_;
-    }
 
   // We place parentheses around fileno to workaround a bug in some versions
   // of MinGW that define fileno as a macro.
-    FMT_API int(fileno)() const;
+  FMT_API int (fileno)() const;
 
-    void vprint(string_view format_str, format_args args)
+  void vprint(string_view format_str, format_args args) {
-    {
     fmt::vprint(file_, format_str, args);
   }
 
-    template<typename... Args>
+  template <typename... Args>
-    inline void print(string_view format_str, const Args &... args)
+  inline void print(string_view format_str, const Args & ... args) {
-    {
     vprint(format_str, make_format_args(args...));
   }
 };
@@ -259,21 +185,16 @@ public:
 // closing the file multiple times will cause a crash on Windows rather
 // than an exception. You can get standard behavior by overriding the
 // invalid parameter handler with _set_invalid_parameter_handler.
-class file
+class file {
-{
+ private:
-private:
   int fd_;  // File descriptor.
 
   // Constructs a file object with a given descriptor.
-    explicit file(int fd)
+  explicit file(int fd) : fd_(fd) {}
-        : fd_(fd)
-    {
-    }
 
-public:
+ public:
   // Possible values for the oflag argument to the constructor.
-    enum
+  enum {
-    {
     RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
     WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
     RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
@@ -285,81 +206,27 @@ public:
   // Opens a file and constructs a file object representing this file.
   FMT_API file(cstring_view path, int oflag);
 
-#if !FMT_USE_RVALUE_REFERENCES
+ private:
-    // Emulate a move constructor and a move assignment operator if rvalue
+  file(const file &) = delete;
-    // references are not supported.
+  void operator=(const file &) = delete;
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        int fd;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-    file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
 
-    // A "move constructor" for moving from an lvalue.
+ public:
-    file(file &other) FMT_NOEXCEPT : fd_(other.fd_)
+  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
-    {
     other.fd_ = -1;
   }
 
-    // A "move assignment operator" for moving from a temporary.
+  file& operator=(file &&other) {
-    file &operator=(Proxy p)
-    {
-        close();
-        fd_ = p.fd;
-        return *this;
-    }
-
-    // A "move assignment operator" for moving from an lvalue.
-    file &operator=(file &other)
-    {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
     return *this;
   }
 
-    // Returns a proxy object for moving from a temporary:
-    //   file f = file(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {fd_};
-        fd_ = -1;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(file);
-
-public:
-    file(file &&other) FMT_NOEXCEPT : fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
-
-    file &operator=(file &&other)
-    {
-        close();
-        fd_ = other.fd_;
-        other.fd_ = -1;
-        return *this;
-    }
-#endif
-
   // Destroys the object closing the file it represents if any.
   FMT_API ~file() FMT_DTOR_NOEXCEPT;
 
   // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
-    {
-        return fd_;
-    }
 
   // Closes the file.
   FMT_API void close();
@@ -398,66 +265,52 @@ public:
 // Returns the memory page size.
 long getpagesize();
 
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
+#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
-#define FMT_LOCALE
+    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
+# define FMT_LOCALE
 #endif
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale
+class Locale {
-{
+ private:
-private:
+# ifdef _MSC_VER
-#ifdef _MSC_VER
   typedef _locale_t locale_t;
 
-    enum
+  enum { LC_NUMERIC_MASK = LC_NUMERIC };
-    {
-        LC_NUMERIC_MASK = LC_NUMERIC
-    };
 
-    static locale_t newlocale(int category_mask, const char *locale, locale_t)
+  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
-    {
     return _create_locale(category_mask, locale);
   }
 
-    static void freelocale(locale_t locale)
+  static void freelocale(locale_t locale) {
-    {
     _free_locale(locale);
   }
 
-    static double strtod_l(const char *nptr, char **endptr, _locale_t locale)
+  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
-    {
     return _strtod_l(nptr, endptr, locale);
   }
-#endif
+# endif
 
   locale_t locale_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
+  Locale(const Locale &) = delete;
+  void operator=(const Locale &) = delete;
 
-public:
+ public:
   typedef locale_t Type;
 
-    Locale()
+  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
-        : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
-    {
     if (!locale_)
       FMT_THROW(system_error(errno, "cannot create locale"));
   }
-    ~Locale()
+  ~Locale() { freelocale(locale_); }
-    {
-        freelocale(locale_);
-    }
 
-    Type get() const
+  Type get() const { return locale_; }
-    {
-        return locale_;
-    }
 
   // Converts string to floating-point number and advances str past the end
   // of the parsed input.
-    double strtod(const char *&str) const
+  double strtod(const char *&str) const {
-    {
     char *end = FMT_NULL;
     double result = strtod_l(str, &end, locale_);
     str = end;
@@ -467,18 +320,4 @@ public:
 #endif  // FMT_LOCALE
 FMT_END_NAMESPACE
 
-#if !FMT_USE_RVALUE_REFERENCES
-namespace std {
-// For compatibility with C++98.
-inline fmt::buffered_file &move(fmt::buffered_file &f)
-{
-    return f;
-}
-inline fmt::file &move(fmt::file &f)
-{
-    return f;
-}
-} // namespace std
-#endif
-
 #endif  // FMT_POSIX_H_

include/spdlog/fmt/bundled/printf.h

@@ -18,141 +18,111 @@ namespace internal {
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
-template<bool IsSigned>
+template <bool IsSigned>
-struct int_checker
+struct int_checker {
-{
+  template <typename T>
-    template<typename T>
+  static bool fits_in_int(T value) {
-    static bool fits_in_int(T value)
-    {
     unsigned max = std::numeric_limits<int>::max();
     return value <= max;
   }
-    static bool fits_in_int(bool)
+  static bool fits_in_int(bool) { return true; }
-    {
-        return true;
-    }
 };
 
-template<>
+template <>
-struct int_checker<true>
+struct int_checker<true> {
-{
+  template <typename T>
-    template<typename T>
+  static bool fits_in_int(T value) {
-    static bool fits_in_int(T value)
+    return value >= std::numeric_limits<int>::min() &&
-    {
+           value <= std::numeric_limits<int>::max();
-        return value >= std::numeric_limits<int>::min() && value <= std::numeric_limits<int>::max();
-    }
-    static bool fits_in_int(int)
-    {
-        return true;
   }
+  static bool fits_in_int(int) { return true; }
 };
 
-class printf_precision_handler : public function<int>
+class printf_precision_handler: public function<int> {
-{
+ public:
-public:
+  template <typename T>
-    template<typename T>
+  typename std::enable_if<std::is_integral<T>::value, int>::type
-    typename std::enable_if<std::is_integral<T>::value, int>::type operator()(T value)
+      operator()(T value) {
-    {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
       FMT_THROW(format_error("number is too big"));
     return static_cast<int>(value);
   }
 
-    template<typename T>
+  template <typename T>
-    typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T)
+  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
-    {
     FMT_THROW(format_error("precision is not integer"));
     return 0;
   }
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int : public function<bool>
+class is_zero_int: public function<bool> {
-{
+ public:
-public:
+  template <typename T>
-    template<typename T>
+  typename std::enable_if<std::is_integral<T>::value, bool>::type
-    typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(T value)
+      operator()(T value) { return value == 0; }
-    {
+
-        return value == 0;
+  template <typename T>
-    }
+  typename std::enable_if<!std::is_integral<T>::value, bool>::type
-
+      operator()(T) { return false; }
-    template<typename T>
-    typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(T)
-    {
-        return false;
-    }
 };
 
-template<typename T>
+template <typename T>
-struct make_unsigned_or_bool : std::make_unsigned<T>
+struct make_unsigned_or_bool : std::make_unsigned<T> {};
-{
-};
 
-template<>
+template <>
-struct make_unsigned_or_bool<bool>
+struct make_unsigned_or_bool<bool> {
-{
   typedef bool type;
 };
 
-template<typename T, typename Context>
+template <typename T, typename Context>
-class arg_converter : public function<void>
+class arg_converter: public function<void> {
-{
+ private:
-private:
   typedef typename Context::char_type Char;
 
   basic_format_arg<Context> &arg_;
   typename Context::char_type type_;
 
-public:
+ public:
   arg_converter(basic_format_arg<Context> &arg, Char type)
-        : arg_(arg)
+    : arg_(arg), type_(type) {}
-        , type_(type)
-    {
-    }
 
-    void operator()(bool value)
+  void operator()(bool value) {
-    {
     if (type_ != 's')
       operator()<bool>(value);
   }
 
-    template<typename U>
+  template <typename U>
-    typename std::enable_if<std::is_integral<U>::value>::type operator()(U value)
+  typename std::enable_if<std::is_integral<U>::value>::type
-    {
+      operator()(U value) {
     bool is_signed = type_ == 'd' || type_ == 'i';
-        typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type TargetType;
+    typedef typename std::conditional<
-        if (const_check(sizeof(TargetType) <= sizeof(int)))
+        std::is_same<T, void>::value, U, T>::type TargetType;
-        {
+    if (const_check(sizeof(TargetType) <= sizeof(int))) {
       // Extra casts are used to silence warnings.
-            if (is_signed)
+      if (is_signed) {
-            {
+        arg_ = internal::make_arg<Context>(
-                arg_ = internal::make_arg<Context>(static_cast<int>(static_cast<TargetType>(value)));
+          static_cast<int>(static_cast<TargetType>(value)));
-            }
+      } else {
-            else
-            {
         typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
-                arg_ = internal::make_arg<Context>(static_cast<unsigned>(static_cast<Unsigned>(value)));
+        arg_ = internal::make_arg<Context>(
+          static_cast<unsigned>(static_cast<Unsigned>(value)));
       }
-        }
+    } else {
-        else
+      if (is_signed) {
-        {
-            if (is_signed)
-            {
         // glibc's printf doesn't sign extend arguments of smaller types:
         //   std::printf("%lld", -42);  // prints "4294967254"
         // but we don't have to do the same because it's a UB.
         arg_ = internal::make_arg<Context>(static_cast<long long>(value));
-            }
+      } else {
-            else
+        arg_ = internal::make_arg<Context>(
-            {
+          static_cast<typename make_unsigned_or_bool<U>::type>(value));
-                arg_ = internal::make_arg<Context>(static_cast<typename make_unsigned_or_bool<U>::type>(value));
       }
     }
   }
 
-    template<typename U>
+  template <typename U>
-    typename std::enable_if<!std::is_integral<U>::value>::type operator()(U)
+  typename std::enable_if<!std::is_integral<U>::value>::type operator()(U) {
-    {
     // No coversion needed for non-integral types.
   }
 };
@@ -161,66 +131,51 @@ public:
 // If T is void, the argument is converted to corresponding signed or unsigned
 // type depending on the type specifier: 'd' and 'i' - signed, other -
 // unsigned).
-template<typename T, typename Context, typename Char>
+template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context> &arg, Char type)
+void convert_arg(basic_format_arg<Context> &arg, Char type) {
-{
   visit(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
-template<typename Context>
+template <typename Context>
-class char_converter : public function<void>
+class char_converter: public function<void> {
-{
+ private:
-private:
   basic_format_arg<Context> &arg_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
+ public:
+  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
-public:
+  template <typename T>
-    explicit char_converter(basic_format_arg<Context> &arg)
+  typename std::enable_if<std::is_integral<T>::value>::type
-        : arg_(arg)
+      operator()(T value) {
-    {
-    }
-
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value>::type operator()(T value)
-    {
     typedef typename Context::char_type Char;
     arg_ = internal::make_arg<Context>(static_cast<Char>(value));
   }
 
-    template<typename T>
+  template <typename T>
-    typename std::enable_if<!std::is_integral<T>::value>::type operator()(T)
+  typename std::enable_if<!std::is_integral<T>::value>::type operator()(T) {
-    {
     // No coversion needed for non-integral types.
   }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-template<typename Char>
+template <typename Char>
-class printf_width_handler : public function<unsigned>
+class printf_width_handler: public function<unsigned> {
-{
+ private:
-private:
   typedef basic_format_specs<Char> format_specs;
 
   format_specs &spec_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
+ public:
-
+  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
-public:
-    explicit printf_width_handler(format_specs &spec)
-        : spec_(spec)
-    {
-    }
 
-    template<typename T>
+  template <typename T>
-    typename std::enable_if<std::is_integral<T>::value, unsigned>::type operator()(T value)
+  typename std::enable_if<std::is_integral<T>::value, unsigned>::type
-    {
+      operator()(T value) {
     typedef typename internal::int_traits<T>::main_type UnsignedType;
     UnsignedType width = static_cast<UnsignedType>(value);
-        if (internal::is_negative(value))
+    if (internal::is_negative(value)) {
-        {
       spec_.align_ = ALIGN_LEFT;
       width = 0 - width;
     }
@@ -230,19 +185,22 @@ public:
     return static_cast<unsigned>(width);
   }
 
-    template<typename T>
+  template <typename T>
-    typename std::enable_if<!std::is_integral<T>::value, unsigned>::type operator()(T)
+  typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
-    {
+      operator()(T) {
     FMT_THROW(format_error("width is not integer"));
     return 0;
   }
 };
 }  // namespace internal
 
-template<typename Range>
+template <typename Range>
 class printf_arg_formatter;
 
-template<typename OutputIt, typename Char, typename ArgFormatter = printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
+template <
+    typename OutputIt, typename Char,
+    typename ArgFormatter =
+      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
 class basic_printf_context;
 
 /**
@@ -250,11 +208,12 @@ class basic_printf_context;
   The ``printf`` argument formatter.
   \endrst
  */
-template<typename Range>
+template <typename Range>
-class printf_arg_formatter : public internal::function<typename internal::arg_formatter_base<Range>::iterator>,
+class printf_arg_formatter:
-                             public internal::arg_formatter_base<Range>
+  public internal::function<
-{
+    typename internal::arg_formatter_base<Range>::iterator>,
-private:
+  public internal::arg_formatter_base<Range> {
+ private:
   typedef typename Range::value_type char_type;
   typedef decltype(internal::declval<Range>().begin()) iterator;
   typedef internal::arg_formatter_base<Range> base;
@@ -262,19 +221,17 @@ private:
 
   context_type &context_;
 
-    void write_null_pointer(char)
+  void write_null_pointer(char) {
-    {
     this->spec().type_ = 0;
     this->write("(nil)");
   }
 
-    void write_null_pointer(wchar_t)
+  void write_null_pointer(wchar_t) {
-    {
     this->spec().type_ = 0;
     this->write(L"(nil)");
   }
 
-public:
+ public:
   typedef typename base::format_specs format_specs;
 
   /**
@@ -284,50 +241,43 @@ public:
     specifier information for standard argument types.
     \endrst
    */
-    printf_arg_formatter(internal::basic_buffer<char_type> &buffer, format_specs &spec, context_type &ctx)
+  printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
-        : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec)
+                       format_specs &spec, context_type &ctx)
-        , context_(ctx)
+    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec),
-    {
+      context_(ctx) {}
-    }
+
-
+  template <typename T>
-    template<typename T>
+  typename std::enable_if<std::is_integral<T>::value, iterator>::type
-    typename std::enable_if<std::is_integral<T>::value, iterator>::type operator()(T value)
+      operator()(T value) {
-    {
     // MSVC2013 fails to compile separate overloads for bool and char_type so
     // use std::is_same instead.
-        if (std::is_same<T, bool>::value)
+    if (std::is_same<T, bool>::value) {
-        {
       format_specs &fmt_spec = this->spec();
       if (fmt_spec.type_ != 's')
         return base::operator()(value ? 1 : 0);
       fmt_spec.type_ = 0;
       this->write(value != 0);
-        }
+    } else if (std::is_same<T, char_type>::value) {
-        else if (std::is_same<T, char_type>::value)
-        {
       format_specs &fmt_spec = this->spec();
       if (fmt_spec.type_ && fmt_spec.type_ != 'c')
         return (*this)(static_cast<int>(value));
       fmt_spec.flags_ = 0;
       fmt_spec.align_ = ALIGN_RIGHT;
       return base::operator()(value);
-        }
+    } else {
-        else
-        {
       return base::operator()(value);
     }
     return this->out();
   }
 
-    template<typename T>
+  template <typename T>
-    typename std::enable_if<std::is_floating_point<T>::value, iterator>::type operator()(T value)
+  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
-    {
+      operator()(T value) {
     return base::operator()(value);
   }
 
   /** Formats a null-terminated C string. */
-    iterator operator()(const char *value)
+  iterator operator()(const char *value) {
-    {
     if (value)
       base::operator()(value);
     else if (this->spec().type_ == 'p')
@@ -338,8 +288,7 @@ public:
   }
 
   /** Formats a null-terminated wide C string. */
-    iterator operator()(const wchar_t *value)
+  iterator operator()(const wchar_t *value) {
-    {
     if (value)
       base::operator()(value);
     else if (this->spec().type_ == 'p')
@@ -349,19 +298,16 @@ public:
     return this->out();
   }
 
-    iterator operator()(basic_string_view<char_type> value)
+  iterator operator()(basic_string_view<char_type> value) {
-    {
     return base::operator()(value);
   }
 
-    iterator operator()(monostate value)
+  iterator operator()(monostate value) {
-    {
     return base::operator()(value);
   }
 
   /** Formats a pointer. */
-    iterator operator()(const void *value)
+  iterator operator()(const void *value) {
-    {
     if (value)
       return base::operator()(value);
     this->spec().type_ = 0;
@@ -370,45 +316,37 @@ public:
   }
 
   /** Formats an argument of a custom (user-defined) type. */
-    iterator operator()(typename basic_format_arg<context_type>::handle handle)
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    {
     handle.format(context_);
     return this->out();
   }
 };
 
-template<typename T>
+template <typename T>
-struct printf_formatter
+struct printf_formatter {
-{
+  template <typename ParseContext>
-    template<typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return ctx.begin();
-    }
 
-    template<typename FormatContext>
+  template <typename FormatContext>
-    auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out())
+  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
-    {
     internal::format_value(internal::get_container(ctx.out()), value);
     return ctx.out();
   }
 };
 
 /** This template formats data and writes the output to a writer. */
-template<typename OutputIt, typename Char, typename ArgFormatter>
+template <typename OutputIt, typename Char, typename ArgFormatter>
-class basic_printf_context : private internal::context_base<OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char>
+class basic_printf_context :
-{
+  private internal::context_base<
-public:
+    OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
+ public:
   /** The character type for the output. */
   typedef Char char_type;
 
-    template<typename T>
+  template <typename T>
-    struct formatter_type
+  struct formatter_type { typedef printf_formatter<T> type; };
-    {
-        typedef printf_formatter<T> type;
-    };
 
-private:
+ private:
   typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
   typedef typename base::format_arg format_arg;
   typedef basic_format_specs<char_type> format_specs;
@@ -418,12 +356,14 @@ private:
 
   // Returns the argument with specified index or, if arg_index is equal
   // to the maximum unsigned value, the next argument.
-    format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+  format_arg get_arg(
+      iterator it,
+      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
 
   // Parses argument index, flags and width and returns the argument index.
   unsigned parse_header(iterator &it, format_specs &spec);
 
-public:
+ public:
   /**
    \rst
    Constructs a ``printf_context`` object. References to the arguments and
@@ -431,26 +371,23 @@ public:
    appropriate lifetimes.
    \endrst
    */
-    basic_printf_context(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<basic_printf_context> args)
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-        : base(out, format_str, args)
+                       basic_format_args<basic_printf_context> args)
-    {
+    : base(out, format_str, args) {}
-    }
 
-    using base::advance_to;
-    using base::out;
   using base::parse_context;
+  using base::out;
+  using base::advance_to;
 
   /** Formats stored arguments and writes the output to the range. */
   void format();
 };
 
-template<typename OutputIt, typename Char, typename AF>
+template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec, iterator &it)
+void basic_printf_context<OutputIt, Char, AF>::parse_flags(
-{
+    format_specs &spec, iterator &it) {
-    for (;;)
+  for (;;) {
-    {
+    switch (*it++) {
-        switch (*it++)
-        {
       case '-':
         spec.align_ = ALIGN_LEFT;
         break;
@@ -473,38 +410,33 @@ void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec, i
   }
 }
 
-template<typename OutputIt, typename Char, typename AF>
+template <typename OutputIt, typename Char, typename AF>
-typename basic_printf_context<OutputIt, Char, AF>::format_arg basic_printf_context<OutputIt, Char, AF>::get_arg(
+typename basic_printf_context<OutputIt, Char, AF>::format_arg
-    iterator it, unsigned arg_index)
+  basic_printf_context<OutputIt, Char, AF>::get_arg(
-{
+    iterator it, unsigned arg_index) {
   (void)it;
   if (arg_index == std::numeric_limits<unsigned>::max())
     return this->do_get_arg(this->parse_context().next_arg_id());
   return base::get_arg(arg_index - 1);
 }
 
-template<typename OutputIt, typename Char, typename AF>
+template <typename OutputIt, typename Char, typename AF>
-unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(iterator &it, format_specs &spec)
+unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
-{
+  iterator &it, format_specs &spec) {
   unsigned arg_index = std::numeric_limits<unsigned>::max();
   char_type c = *it;
-    if (c >= '0' && c <= '9')
+  if (c >= '0' && c <= '9') {
-    {
     // Parse an argument index (if followed by '$') or a width possibly
     // preceded with '0' flag(s).
     internal::error_handler eh;
     unsigned value = parse_nonnegative_int(it, eh);
-        if (*it == '$')
+    if (*it == '$') {  // value is an argument index
-        { // value is an argument index
       ++it;
       arg_index = value;
-        }
+    } else {
-        else
-        {
       if (c == '0')
         spec.fill_ = '0';
-            if (value != 0)
+      if (value != 0) {
-            {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
         spec.width_ = value;
@@ -514,33 +446,27 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(iterator &it, fo
   }
   parse_flags(spec, it);
   // Parse width.
-    if (*it >= '0' && *it <= '9')
+  if (*it >= '0' && *it <= '9') {
-    {
     internal::error_handler eh;
     spec.width_ = parse_nonnegative_int(it, eh);
-    }
+  } else if (*it == '*') {
-    else if (*it == '*')
-    {
     ++it;
-        spec.width_ = visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
+    spec.width_ =
+        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
   }
   return arg_index;
 }
 
-template<typename OutputIt, typename Char, typename AF>
+template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::format()
+void basic_printf_context<OutputIt, Char, AF>::format() {
-{
   auto &buffer = internal::get_container(this->out());
   auto start = iterator(this->parse_context());
   auto it = start;
   using internal::pointer_from;
-    while (*it)
+  while (*it) {
-    {
     char_type c = *it++;
-        if (c != '%')
+    if (c != '%') continue;
-            continue;
+    if (*it == c) {
-        if (*it == c)
-        {
       buffer.append(pointer_from(start), pointer_from(it));
       start = ++it;
       continue;
@@ -554,21 +480,16 @@ void basic_printf_context<OutputIt, Char, AF>::format()
     unsigned arg_index = parse_header(it, spec);
 
     // Parse precision.
-        if (*it == '.')
+    if (*it == '.') {
-        {
       ++it;
-            if ('0' <= *it && *it <= '9')
+      if ('0' <= *it && *it <= '9') {
-            {
         internal::error_handler eh;
         spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
-            }
+      } else if (*it == '*') {
-            else if (*it == '*')
-            {
         ++it;
-                spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it));
+        spec.precision_ =
-            }
+            visit(internal::printf_precision_handler(), get_arg(it));
-            else
+      } else {
-            {
         spec.precision_ = 0;
       }
     }
@@ -576,8 +497,7 @@ void basic_printf_context<OutputIt, Char, AF>::format()
     format_arg arg = get_arg(it, arg_index);
     if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
       spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
-        if (spec.fill_ == '0')
+    if (spec.fill_ == '0') {
-        {
       if (arg.is_arithmetic())
         spec.align_ = ALIGN_NUMERIC;
       else
@@ -586,8 +506,7 @@ void basic_printf_context<OutputIt, Char, AF>::format()
 
     // Parse length and convert the argument to the required type.
     using internal::convert_arg;
-        switch (*it++)
+    switch (*it++) {
-        {
     case 'h':
       if (*it == 'h')
         convert_arg<signed char>(arg, *++it);
@@ -622,13 +541,10 @@ void basic_printf_context<OutputIt, Char, AF>::format()
     if (!*it)
       FMT_THROW(format_error("invalid format string"));
     spec.type_ = static_cast<char>(*it++);
-        if (arg.is_integral())
+    if (arg.is_integral()) {
-        {
       // Normalize type.
-            switch (spec.type_)
+      switch (spec.type_) {
-            {
+      case 'i': case 'u':
-            case 'i':
-            case 'u':
         spec.type_ = 'd';
         break;
       case 'c':
@@ -646,28 +562,28 @@ void basic_printf_context<OutputIt, Char, AF>::format()
   buffer.append(pointer_from(start), pointer_from(it));
 }
 
-template<typename Char, typename Context>
+template <typename Char, typename Context>
-void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
+void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
-{
+            basic_format_args<Context> args) {
   Context(std::back_inserter(buf), format, args).format();
 }
 
-template<typename Buffer>
+template <typename Buffer>
-struct printf_context
+struct printf_context {
-{
+  typedef basic_printf_context<
-    typedef basic_printf_context<std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
 };
 
-template<typename... Args>
+template <typename ...Args>
-inline format_arg_store<printf_context<internal::buffer>::type, Args...> make_printf_args(const Args &... args)
+inline format_arg_store<printf_context<internal::buffer>::type, Args...>
-{
+    make_printf_args(const Args & ... args) {
-    return format_arg_store<printf_context<internal::buffer>::type, Args...>(args...);
+  return format_arg_store<printf_context<internal::buffer>::type, Args...>(
+      args...);
 }
 typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
 typedef basic_format_args<printf_context<internal::wbuffer>::type> wprintf_args;
 
-inline std::string vsprintf(string_view format, printf_args args)
+inline std::string vsprintf(string_view format, printf_args args) {
-{
   memory_buffer buffer;
   printf(buffer, format, args);
   return to_string(buffer);
@@ -682,33 +598,33 @@ inline std::string vsprintf(string_view format, printf_args args)
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-template<typename... Args>
+template <typename... Args>
-inline std::string sprintf(string_view format_str, const Args &... args)
+inline std::string sprintf(string_view format_str, const Args & ... args) {
-{
+  return vsprintf(format_str,
-    return vsprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-inline std::wstring vsprintf(wstring_view format, wprintf_args args)
+inline std::wstring vsprintf(wstring_view format, wprintf_args args) {
-{
   wmemory_buffer buffer;
   printf(buffer, format, args);
   return to_string(buffer);
 }
 
-template<typename... Args>
+template <typename... Args>
-inline std::wstring sprintf(wstring_view format_str, const Args &... args)
+inline std::wstring sprintf(wstring_view format_str, const Args & ... args) {
-{
+  return vsprintf(format_str,
-    return vsprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-template<typename Char>
+template <typename Char>
-inline int vfprintf(
+inline int vfprintf(std::FILE *f, basic_string_view<Char> format,
-    std::FILE *f, basic_string_view<Char> format, basic_format_args<typename printf_context<internal::basic_buffer<Char>>::type> args)
+                    basic_format_args<typename printf_context<
-{
+                      internal::basic_buffer<Char>>::type> args) {
   basic_memory_buffer<Char> buffer;
   printf(buffer, format, args);
   std::size_t size = buffer.size();
-    return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+  return std::fwrite(
+    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
 }
 
 /**
@@ -720,26 +636,25 @@ inline int vfprintf(
     fmt::fprintf(stderr, "Don't %s!", "panic");
   \endrst
  */
-template<typename... Args>
+template <typename... Args>
-inline int fprintf(std::FILE *f, string_view format_str, const Args &... args)
+inline int fprintf(std::FILE *f, string_view format_str, const Args & ... args) {
-{
+  auto vargs = make_format_args<
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+    typename printf_context<internal::buffer>::type>(args...);
   return vfprintf<char>(f, format_str, vargs);
 }
 
-template<typename... Args>
+template <typename... Args>
-inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args)
+inline int fprintf(std::FILE *f, wstring_view format_str,
-{
+                   const Args & ... args) {
-    return vfprintf(f, format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+  return vfprintf(f, format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vprintf(string_view format, printf_args args)
+inline int vprintf(string_view format, printf_args args) {
-{
   return vfprintf(stdout, format, args);
 }
 
-inline int vprintf(wstring_view format, wprintf_args args)
+inline int vprintf(wstring_view format, wprintf_args args) {
-{
   return vfprintf(stdout, format, args);
 }
 
@@ -752,28 +667,28 @@ inline int vprintf(wstring_view format, wprintf_args args)
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template<typename... Args>
+template <typename... Args>
-inline int printf(string_view format_str, const Args &... args)
+inline int printf(string_view format_str, const Args & ... args) {
-{
+  return vprintf(format_str,
-    return vprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-template<typename... Args>
+template <typename... Args>
-inline int printf(wstring_view format_str, const Args &... args)
+inline int printf(wstring_view format_str, const Args & ... args) {
-{
+  return vprintf(format_str,
-    return vprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vfprintf(std::ostream &os, string_view format_str, printf_args args)
+inline int vfprintf(std::ostream &os, string_view format_str,
-{
+                    printf_args args) {
   memory_buffer buffer;
   printf(buffer, format_str, args);
   internal::write(os, buffer);
   return static_cast<int>(buffer.size());
 }
 
-inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args)
+inline int vfprintf(std::wostream &os, wstring_view format_str,
-{
+                    wprintf_args args) {
   wmemory_buffer buffer;
   printf(buffer, format_str, args);
   internal::write(os, buffer);
@@ -789,17 +704,19 @@ inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args arg
     fmt::fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
-template<typename... Args>
+template <typename... Args>
-inline int fprintf(std::ostream &os, string_view format_str, const Args &... args)
+inline int fprintf(std::ostream &os, string_view format_str,
-{
+                   const Args & ... args) {
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
   return vfprintf(os, format_str, vargs);
 }
 
-template<typename... Args>
+template <typename... Args>
-inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args)
+inline int fprintf(std::wostream &os, wstring_view format_str,
-{
+                   const Args & ... args) {
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
   return vfprintf(os, format_str, vargs);
 }
 FMT_END_NAMESPACE

include/spdlog/fmt/bundled/ranges.h

@@ -17,270 +17,233 @@
 
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-template<typename Char>
+template <typename Char>
-struct formatting_base
+struct formatting_base {
-{
+  template <typename ParseContext>
-    template<typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
     return ctx.begin();
   }
 };
 
-template<typename Char, typename Enable = void>
+template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char>
+struct formatting_range : formatting_base<Char> {
-{
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-    static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
-                                                                                                    // range.
   Char prefix;
   Char delimiter;
   Char postfix;
-    formatting_range()
+  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
-        : prefix('{')
-        , delimiter(',')
-        , postfix('}')
-    {
-    }
   static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
-template<typename Char, typename Enable = void>
+template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char>
+struct formatting_tuple : formatting_base<Char> {
-{
   Char prefix;
   Char delimiter;
   Char postfix;
-    formatting_tuple()
+  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
-        : prefix('(')
-        , delimiter(',')
-        , postfix(')')
-    {
-    }
   static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 namespace internal {
 
-template<typename RangeT, typename OutputIterator>
+template <typename RangeT, typename OutputIterator>
-void copy(const RangeT &range, OutputIterator out)
+void copy(const RangeT &range, OutputIterator out) {
-{
   for (auto it = range.begin(), end = range.end(); it != end; ++it)
     *out++ = *it;
 }
 
-template<typename OutputIterator>
+template <typename OutputIterator>
-void copy(const char *str, OutputIterator out)
+void copy(const char *str, OutputIterator out) {
-{
   const char *p_curr = str;
-    while (*p_curr)
+  while (*p_curr) {
-    {
     *out++ = *p_curr++;
   }
 }
 
-template<typename OutputIterator>
+template <typename OutputIterator>
-void copy(char ch, OutputIterator out)
+void copy(char ch, OutputIterator out) {
-{
   *out++ = ch;
 }
 
 /// Return true value if T has std::string interface, like std::string_view.
-template<typename T>
+template <typename T>
-class is_like_std_string
+class is_like_std_string {
-{
+  template <typename U>
-    template<typename U>
+  static auto check(U *p) ->
-    static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int());
+    decltype(p->find('a'), p->length(), p->data(), int());
-    template<typename>
+  template <typename>
   static void check(...);
 
-public:
+ public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
-template<typename... Ts>
+template <typename... Ts>
-struct conditional_helper
+struct conditional_helper {};
-{
-};
 
-template<typename T, typename _ = void>
+template <typename T, typename _ = void>
-struct is_range_ : std::false_type
+struct is_range_ : std::false_type {};
-{
-};
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template<typename T>
+template <typename T>
-struct is_range_<T, typename std::conditional<false,
+struct is_range_<T, typename std::conditional<
-                        conditional_helper<decltype(internal::declval<T>().begin()), decltype(internal::declval<T>().end())>, void>::type>
+                    false,
-    : std::true_type
+                    conditional_helper<decltype(internal::declval<T>().begin()),
-{
+                                       decltype(internal::declval<T>().end())>,
-};
+                    void>::type> : std::true_type {};
 #endif
 
 /// tuple_size and tuple_element check.
-template<typename T>
+template <typename T>
-class is_tuple_like_
+class is_tuple_like_ {
-{
+  template <typename U>
-    template<typename U>
+  static auto check(U *p) ->
-    static auto check(U *p) -> decltype(std::tuple_size<U>::value, internal::declval<typename std::tuple_element<0, U>::type>(), int());
+    decltype(std::tuple_size<U>::value,
-    template<typename>
+      internal::declval<typename std::tuple_element<0, U>::type>(), int());
+  template <typename>
   static void check(...);
 
-public:
+ public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template<typename T, T... N>
+template <typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
-template<std::size_t... N>
+template <std::size_t... N>
 using index_sequence = std::index_sequence<N...>;
-template<std::size_t N>
+template <std::size_t N>
 using make_index_sequence = std::make_index_sequence<N>;
 #else
-template<typename T, T... N>
+template <typename T, T... N>
-struct integer_sequence
+struct integer_sequence {
-{
   typedef T value_type;
 
-    static FMT_CONSTEXPR std::size_t size()
+  static FMT_CONSTEXPR std::size_t size() {
-    {
     return sizeof...(N);
   }
 };
 
-template<std::size_t... N>
+template <std::size_t... N>
 using index_sequence = integer_sequence<std::size_t, N...>;
 
-template<typename T, std::size_t N, T... Ns>
+template <typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-{
+template <typename T, T... Ns>
-};
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
-template<typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
-{
-};
 
-template<std::size_t N>
+template <std::size_t N>
 using make_index_sequence = make_integer_sequence<std::size_t, N>;
 #endif
 
-template<class Tuple, class F, size_t... Is>
+template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT
+void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
-{
   using std::get;
   // using free function get<I>(T) now.
   const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
   (void)_;  // blocks warnings
 }
 
-template<class T>
+template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
-{
+get_indexes(T const &) { return {}; }
-    return {};
-}
 
-template<class Tuple, class F>
+template <class Tuple, class F>
-void for_each(Tuple &&tup, F &&f)
+void for_each(Tuple &&tup, F &&f) {
-{
   const auto indexes = get_indexes(tup);
   for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-    bool add_space, const Arg &, typename std::enable_if<!is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
+  typename std::enable_if<
-{
+    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
   return add_space ? " {}" : "{}";
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-    bool add_space, const Arg &, typename std::enable_if<is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
+  typename std::enable_if<
-{
+    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
   return add_space ? " \"{}\"" : "\"{}\"";
 }
 
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-{
   return add_space ? " \"{}\"" : "\"{}\"";
 }
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
-{
     return add_space ? L" \"{}\"" : L"\"{}\"";
 }
 
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
-{
     return add_space ? " '{}'" : "'{}'";
 }
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
-{
     return add_space ? L" '{}'" : L"'{}'";
 }
 
 }  // namespace internal
 
-template<typename T>
+template <typename T>
-struct is_tuple_like
+struct is_tuple_like {
-{
+  static FMT_CONSTEXPR_DECL const bool value =
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+    internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
 };
 
-template<typename TupleT, typename Char>
+template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type>
+struct formatter<TupleT, Char, 
-{
+    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
 private:
   // C++11 generic lambda for format()
-    template<typename FormatContext>
+  template <typename FormatContext>
-    struct format_each
+  struct format_each {
-    {
+    template <typename T>
-        template<typename T>
+    void operator()(const T& v) {
-        void operator()(const T &v)
+      if (i > 0) {
-        {
+        if (formatting.add_prepostfix_space) {
-            if (i > 0)
-            {
-                if (formatting.add_prepostfix_space)
-                {
           *out++ = ' ';
         }
         internal::copy(formatting.delimiter, out);
       }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
+      format_to(out,
+                internal::format_str_quoted(
+                    (formatting.add_delimiter_spaces && i > 0), v),
+                v);
       ++i;
     }
 
-        formatting_tuple<Char> &formatting;
+    formatting_tuple<Char>& formatting;
-        std::size_t &i;
+    std::size_t& i;
     typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
   };
 
 public:
   formatting_tuple<Char> formatting;
 
-    template<typename ParseContext>
+  template <typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    {
     return formatting.parse(ctx);
   }
 
-    template<typename FormatContext = format_context>
+  template <typename FormatContext = format_context>
-    auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
-    {
     auto out = ctx.out();
     std::size_t i = 0;
     internal::copy(formatting.prefix, out);
 
     internal::for_each(values, format_each<FormatContext>{formatting, i, out});
-        if (formatting.add_prepostfix_space)
+    if (formatting.add_prepostfix_space) {
-        {
       *out++ = ' ';
     }
     internal::copy(formatting.postfix, out);
@@ -289,49 +252,46 @@ public:
   }
 };
 
-template<typename T>
+template <typename T>
-struct is_range
+struct is_range {
-{
+  static FMT_CONSTEXPR_DECL const bool value =
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
+    internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
 };
 
-template<typename RangeT, typename Char>
+template <typename RangeT, typename Char>
-struct formatter<RangeT, Char, typename std::enable_if<fmt::is_range<RangeT>::value>::type>
+struct formatter<RangeT, Char,
-{
+    typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
 
   formatting_range<Char> formatting;
 
-    template<typename ParseContext>
+  template <typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    {
     return formatting.parse(ctx);
   }
 
-    template<typename FormatContext>
+  template <typename FormatContext>
-    typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
+  typename FormatContext::iterator format(
-    {
+      const RangeT &values, FormatContext &ctx) {
     auto out = ctx.out();
     internal::copy(formatting.prefix, out);
     std::size_t i = 0;
-        for (auto it = values.begin(), end = values.end(); it != end; ++it)
+    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
-        {
+      if (i > 0) {
-            if (i > 0)
+        if (formatting.add_prepostfix_space) {
-            {
-                if (formatting.add_prepostfix_space)
-                {
           *out++ = ' ';
         }
         internal::copy(formatting.delimiter, out);
       }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
+      format_to(out,
-            if (++i > formatting.range_length_limit)
+                internal::format_str_quoted(
-            {
+                    (formatting.add_delimiter_spaces && i > 0), *it),
+                *it);
+      if (++i > formatting.range_length_limit) {
         format_to(out, " ... <other elements>");
         break;
       }
     }
-        if (formatting.add_prepostfix_space)
+    if (formatting.add_prepostfix_space) {
-        {
       *out++ = ' ';
     }
     internal::copy(formatting.postfix, out);
@@ -342,3 +302,4 @@ struct formatter<RangeT, Char, typename std::enable_if<fmt::is_range<RangeT>::va
 FMT_END_NAMESPACE
 
 #endif // FMT_RANGES_H_
+

include/spdlog/fmt/bundled/time.h

@@ -9,70 +9,42 @@
 #define FMT_TIME_H_
 
 #include "format.h"
-#include <ctime>
 
 FMT_BEGIN_NAMESPACE
 
-namespace internal {
+namespace internal{
-inline null<> localtime_r(...)
+inline null<> localtime_r(...) { return null<>(); }
-{
+inline null<> localtime_s(...) { return null<>(); }
-    return null<>();
+inline null<> gmtime_r(...) { return null<>(); }
-}
+inline null<> gmtime_s(...) { return null<>(); }
-inline null<> localtime_s(...)
-{
-    return null<>();
-}
-inline null<> gmtime_r(...)
-{
-    return null<>();
-}
-inline null<> gmtime_s(...)
-{
-    return null<>();
 }
-} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time)
+inline std::tm localtime(std::time_t time) {
-{
+  struct dispatcher {
-    struct dispatcher
-    {
     std::time_t time_;
     std::tm tm_;
 
-        dispatcher(std::time_t t)
+    dispatcher(std::time_t t): time_(t) {}
-            : time_(t)
-        {
-        }
 
-        bool run()
+    bool run() {
-        {
       using namespace fmt::internal;
       return handle(localtime_r(&time_, &tm_));
     }
 
-        bool handle(std::tm *tm)
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
-        {
-            return tm != FMT_NULL;
-        }
 
-        bool handle(internal::null<>)
+    bool handle(internal::null<>) {
-        {
       using namespace fmt::internal;
       return fallback(localtime_s(&tm_, &time_));
     }
 
-        bool fallback(int res)
+    bool fallback(int res) { return res == 0; }
-        {
-            return res == 0;
-        }
 
-        bool fallback(internal::null<>)
+    bool fallback(internal::null<>) {
-        {
       using namespace fmt::internal;
       std::tm *tm = std::localtime(&time_);
-            if (tm)
+      if (tm) tm_ = *tm;
-                tm_ = *tm;
       return tm != FMT_NULL;
     }
   };
@@ -84,45 +56,30 @@ inline std::tm localtime(std::time_t time)
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time)
+inline std::tm gmtime(std::time_t time) {
-{
+  struct dispatcher {
-    struct dispatcher
-    {
     std::time_t time_;
     std::tm tm_;
 
-        dispatcher(std::time_t t)
+    dispatcher(std::time_t t): time_(t) {}
-            : time_(t)
-        {
-        }
 
-        bool run()
+    bool run() {
-        {
       using namespace fmt::internal;
       return handle(gmtime_r(&time_, &tm_));
     }
 
-        bool handle(std::tm *tm)
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
-        {
-            return tm != FMT_NULL;
-        }
 
-        bool handle(internal::null<>)
+    bool handle(internal::null<>) {
-        {
       using namespace fmt::internal;
       return fallback(gmtime_s(&tm_, &time_));
     }
 
-        bool fallback(int res)
+    bool fallback(int res) { return res == 0; }
-        {
-            return res == 0;
-        }
 
-        bool fallback(internal::null<>)
+    bool fallback(internal::null<>) {
-        {
       std::tm *tm = std::gmtime(&time_);
-            if (tm)
+      if (tm) tm_ = *tm;
-                tm_ = *tm;
       return tm != FMT_NULL;
     }
   };
@@ -134,23 +91,21 @@ inline std::tm gmtime(std::time_t time)
 }
 
 namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
+inline std::size_t strftime(char *str, std::size_t count, const char *format,
-{
+                            const std::tm *time) {
   return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time)
+inline std::size_t strftime(wchar_t *str, std::size_t count,
-{
+                            const wchar_t *format, const std::tm *time) {
   return std::wcsftime(str, count, format, time);
 }
-} // namespace internal
+}
-
+
-template<typename Char>
+template <typename Char>
-struct formatter<std::tm, Char>
+struct formatter<std::tm, Char> {
-{
+  template <typename ParseContext>
-    template<typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
     auto it = internal::null_terminating_iterator<Char>(ctx);
     if (*it == ':')
       ++it;
@@ -164,22 +119,19 @@ struct formatter<std::tm, Char>
     return pointer_from(end);
   }
 
-    template<typename FormatContext>
+  template <typename FormatContext>
-    auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
+  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
-    {
     internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
     std::size_t start = buf.size();
-        for (;;)
+    for (;;) {
-        {
       std::size_t size = buf.capacity() - start;
-            std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      std::size_t count =
-            if (count != 0)
+        internal::strftime(&buf[start], size, &tm_format[0], &tm);
-            {
+      if (count != 0) {
         buf.resize(start + count);
         break;
       }
-            if (size >= tm_format.size() * 256)
+      if (size >= tm_format.size() * 256) {
-            {
         // If the buffer is 256 times larger than the format string, assume
         // that `strftime` gives an empty result. There doesn't seem to be a
         // better way to distinguish the two cases:

include/spdlog/logger.h

@@ -22,9 +22,6 @@
 #include "spdlog/formatter.h"
 #include "spdlog/sinks/sink.h"
 
-#include <memory>
-#include <string>
-#include <vector>
 
 namespace spdlog {
 
@@ -154,7 +151,7 @@ protected:
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
     std::wstring_convert<std::codecvt_utf8<wchar_t>> wstring_converter_;
-    std::mutex wstring_converter_mutex_;
+    mutex wstring_converter_mutex_;
 #endif
 };
 } // namespace spdlog

include/spdlog/sinks/ansicolor_sink.h

@@ -9,10 +9,6 @@
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/details/os.h"
 
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
 
 namespace spdlog {
 namespace sinks {
@@ -50,7 +46,7 @@ public:
 
     void set_color(level::level_enum color_level, const std::string &color)
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         colors_[color_level] = color;
     }
 
@@ -84,11 +80,11 @@ public:
     const std::string on_cyan = "\033[46m";
     const std::string on_white = "\033[47m";
 
-    void log(const details::log_msg &msg) override
+    void log(const details::log_msg &msg) SPDLOG_FINAL override
     {
         // Wrap the originally formatted message in color codes.
         // If color is not supported in the terminal, log as is instead.
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
 
         fmt::memory_buffer formatted;
         formatter_->format(msg, formatted);
@@ -112,19 +108,19 @@ public:
 
     void flush() override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         fflush(target_file_);
     }
 
     void set_pattern(const std::string &pattern) SPDLOG_FINAL
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
     }
 
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::move(sink_formatter);
     }
 

include/spdlog/sinks/base_sink.h

@@ -32,25 +32,25 @@ public:
 
     void log(const details::log_msg &msg) SPDLOG_FINAL
     {
-        std::lock_guard<Mutex> lock(mutex_);
+        lock_guard<Mutex> lock(mutex_);
         sink_it_(msg);
     }
 
     void flush() SPDLOG_FINAL override
     {
-        std::lock_guard<Mutex> lock(mutex_);
+        lock_guard<Mutex> lock(mutex_);
         flush_();
     }
 
     void set_pattern(const std::string &pattern) SPDLOG_FINAL override
     {
-        std::lock_guard<Mutex> lock(mutex_);
+        lock_guard<Mutex> lock(mutex_);
         formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
     }
 
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) SPDLOG_FINAL override
     {
-        std::lock_guard<Mutex> lock(mutex_);
+        lock_guard<Mutex> lock(mutex_);
         formatter_ = std::move(sink_formatter);
     }
 

include/spdlog/sinks/basic_file_sink.h

@@ -9,8 +9,6 @@
 #include "spdlog/sinks/base_sink.h"
 #include "spdlog/spdlog.h"
 
-#include <mutex>
-#include <string>
 
 namespace spdlog {
 namespace sinks {
@@ -43,7 +41,7 @@ private:
     details::file_helper file_helper_;
 };
 
-using basic_file_sink_mt = basic_file_sink<std::mutex>;
+using basic_file_sink_mt = basic_file_sink<mutex>;
 using basic_file_sink_st = basic_file_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/daily_file_sink.h

@@ -10,11 +10,6 @@
 #include "spdlog/sinks/base_sink.h"
 #include "spdlog/spdlog.h"
 
-#include <chrono>
-#include <cstdio>
-#include <ctime>
-#include <mutex>
-#include <string>
 
 namespace spdlog {
 namespace sinks {
@@ -97,7 +92,7 @@ private:
         {
             return rotation_time;
         }
-        return {rotation_time + std::chrono::hours(24)};
+        return {rotation_time + chrono::hours(24)};
     }
 
     filename_t base_filename_;
@@ -108,7 +103,7 @@ private:
     bool truncate_;
 };
 
-using daily_file_sink_mt = daily_file_sink<std::mutex>;
+using daily_file_sink_mt = daily_file_sink<mutex>;
 using daily_file_sink_st = daily_file_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/dist_sink.h

@@ -9,10 +9,6 @@
 #include "spdlog/details/log_msg.h"
 #include "spdlog/details/null_mutex.h"
 
-#include <algorithm>
-#include <memory>
-#include <mutex>
-#include <vector>
 
 // Distribution sink (mux). Stores a vector of sinks which get called when log
 // is called
@@ -30,13 +26,13 @@ public:
 
     void add_sink(std::shared_ptr<sink> sink)
     {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
         sinks_.push_back(sink);
     }
 
     void remove_sink(std::shared_ptr<sink> sink)
     {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
         sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
     }
 
@@ -61,7 +57,7 @@ protected:
     std::vector<std::shared_ptr<sink>> sinks_;
 };
 
-using dist_sink_mt = dist_sink<std::mutex>;
+using dist_sink_mt = dist_sink<mutex>;
 using dist_sink_st = dist_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/null_sink.h

@@ -8,7 +8,6 @@
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/base_sink.h"
 
-#include <mutex>
 
 namespace spdlog {
 namespace sinks {
@@ -21,7 +20,7 @@ protected:
     void flush_() override {}
 };
 
-using null_sink_mt = null_sink<std::mutex>;
+using null_sink_mt = null_sink<mutex>;
 using null_sink_st = null_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/ostream_sink.h

@@ -8,8 +8,6 @@
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/base_sink.h"
 
-#include <mutex>
-#include <ostream>
 
 namespace spdlog {
 namespace sinks {
@@ -44,7 +42,7 @@ protected:
     bool force_flush_;
 };
 
-using ostream_sink_mt = ostream_sink<std::mutex>;
+using ostream_sink_mt = ostream_sink<mutex>;
 using ostream_sink_st = ostream_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/rotating_file_sink.h

@@ -4,18 +4,12 @@
 //
 
 #pragma once
+#include "spdlog/spdlog.h"
 #include "spdlog/details/file_helper.h"
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/fmt/fmt.h"
 #include "spdlog/sinks/base_sink.h"
-#include "spdlog/spdlog.h"
 
-#include <cerrno>
-#include <chrono>
-#include <ctime>
-#include <mutex>
-#include <string>
-#include <tuple>
 
 namespace spdlog {
 namespace sinks {
@@ -119,7 +113,7 @@ private:
     details::file_helper file_helper_;
 };
 
-using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
+using rotating_file_sink_mt = rotating_file_sink<mutex>;
 using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
 
 } // namespace sinks

include/spdlog/sinks/stdout_sinks.h

@@ -5,14 +5,11 @@
 
 #pragma once
 
+#include "spdlog/spdlog.h"
 #include "spdlog/details/console_globals.h"
 #include "spdlog/details/null_mutex.h"
-#include "spdlog/spdlog.h"
 
-#include <cstdio>
+#include "spdlog/details/console_globals.h"
-#include <memory>
-#include <mutex>
-#include <spdlog/details/console_globals.h>
 
 namespace spdlog {
 
@@ -35,7 +32,7 @@ public:
 
     void log(const details::log_msg &msg) override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         fmt::memory_buffer formatted;
         formatter_->format(msg, formatted);
         fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
@@ -44,19 +41,19 @@ public:
 
     void flush() override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         fflush(file_);
     }
 
     void set_pattern(const std::string &pattern) override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
     }
 
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::move(sink_formatter);
     }
 

include/spdlog/sinks/syslog_sink.h

@@ -8,8 +8,6 @@
 #include "spdlog/sinks/base_sink.h"
 #include "spdlog/spdlog.h"
 
-#include <array>
-#include <string>
 #include <syslog.h>
 
 namespace spdlog {
@@ -70,7 +68,7 @@ private:
     }
 };
 
-using syslog_sink_mt = syslog_sink<std::mutex>;
+using syslog_sink_mt = syslog_sink<mutex>;
 using syslog_sink_st = syslog_sink<details::null_mutex>;
 } // namespace sinks
 

include/spdlog/sinks/wincolor_sink.h

@@ -10,10 +10,6 @@
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/sink.h"
 
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
 #include <wincon.h>
 
 namespace spdlog {
@@ -57,13 +53,13 @@ public:
     // change the color for the given level
     void set_color(level::level_enum level, WORD color)
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         colors_[level] = color;
     }
 
     void log(const details::log_msg &msg) SPDLOG_FINAL override
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         fmt::memory_buffer formatted;
         formatter_->format(msg, formatted);
         if (msg.color_range_end > msg.color_range_start)
@@ -92,13 +88,13 @@ public:
 
     void set_pattern(const std::string &pattern) override SPDLOG_FINAL
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
     }
 
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override SPDLOG_FINAL
     {
-        std::lock_guard<mutex_t> lock(mutex_);
+        lock_guard<mutex_t> lock(mutex_);
         formatter_ = std::move(sink_formatter);
     }
 

include/spdlog/spdlog.h

@@ -12,10 +12,6 @@
 #include "spdlog/logger.h"
 #include "spdlog/version.h"
 
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
 
 namespace spdlog {
 
@@ -81,7 +77,7 @@ inline void flush_on(level::level_enum log_level)
 
 // Start/Restart a periodic flusher thread
 // Warning: Use only if all your loggers are thread safe!
-inline void flush_every(std::chrono::seconds interval)
+inline void flush_every(chrono::seconds interval)
 {
     details::registry::instance().flush_every(interval);
 }

tests/CMakeLists.txt

@@ -1,6 +1,5 @@
 project(spdlog-utests CXX)
 enable_testing()
-find_package(Threads REQUIRED)
 
 set(SPDLOG_UTESTS_SOURCES
     errors.cpp
@@ -17,7 +16,6 @@ set(SPDLOG_UTESTS_SOURCES
     main.cpp)
 
 add_executable(${PROJECT_NAME} ${SPDLOG_UTESTS_SOURCES})
-target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
 target_link_libraries(${PROJECT_NAME} PRIVATE spdlog::spdlog)
 
 add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME})

tests/errors.cpp

@@ -5,7 +5,7 @@
 
 #include <iostream>
 
-class failing_sink : public spdlog::sinks::base_sink<std::mutex>
+class failing_sink : public spdlog::sinks::base_sink<spdlog::mutex>
 {
 public:
     failing_sink() = default;

tests/file_log.cpp

@@ -81,7 +81,7 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
 
 TEST_CASE("daily_logger with dateonly calculator", "[daily_logger_dateonly]]")
 {
-    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>;
+    using sink_type = spdlog::sinks::daily_file_sink<spdlog::mutex, spdlog::sinks::daily_filename_calculator>;
 
     prepare_logdir();
     // calculate filename (time based)
@@ -113,7 +113,7 @@ struct custom_daily_file_name_calculator
 
 TEST_CASE("daily_logger with custom calculator", "[daily_logger_custom]]")
 {
-    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, custom_daily_file_name_calculator>;
+    using sink_type = spdlog::sinks::daily_file_sink<spdlog::mutex, custom_daily_file_name_calculator>;
 
     prepare_logdir();
     // calculate filename (time based)

tests/test_async.cpp

@@ -84,10 +84,10 @@ TEST_CASE("async periodic flush", "[async]")
 
     auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(logger->sinks()[0]);
 
-    spdlog::flush_every(std::chrono::seconds(1));
+    spdlog::flush_every(chrono::seconds(1));
-    std::this_thread::sleep_for(std::chrono::milliseconds(1100));
+    spdlog::details::os::sleep_for_millis(1100);
     REQUIRE(test_sink->flush_counter() == 1);
-    spdlog::flush_every(std::chrono::seconds(0));
+    spdlog::flush_every(chrono::seconds(0));
     spdlog::drop_all();
 }
 
@@ -95,7 +95,7 @@ TEST_CASE("tp->wait_empty() ", "[async]")
 {
     using namespace spdlog;
     auto test_sink = std::make_shared<sinks::test_sink_mt>();
-    test_sink->set_delay(std::chrono::milliseconds(5));
+    test_sink->set_delay(chrono::milliseconds(5));
     size_t messages = 100;
 
     auto tp = std::make_shared<details::thread_pool>(messages, 2);
@@ -114,6 +114,8 @@ TEST_CASE("tp->wait_empty() ", "[async]")
 TEST_CASE("multi threads", "[async]")
 {
     using namespace spdlog;
+    using spdlog::details::thread;
+
     auto test_sink = std::make_shared<sinks::test_sink_mt>();
     size_t queue_size = 128;
     size_t messages = 256;
@@ -122,7 +124,7 @@ TEST_CASE("multi threads", "[async]")
         auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
         auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block);
 
-        std::vector<std::thread> threads;
+        std::vector<thread> threads;
         for (size_t i = 0; i < n_threads; i++)
         {
             threads.emplace_back([logger, messages] {

tests/test_misc.cpp

@@ -85,9 +85,9 @@ TEST_CASE("periodic flush", "[periodic_flush]")
 
     auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(logger->sinks()[0]);
 
-    spdlog::flush_every(std::chrono::seconds(1));
+    spdlog::flush_every(spdlog::chrono::seconds(1));
-    std::this_thread::sleep_for(std::chrono::milliseconds(1100));
+    spdlog::details::os::sleep_for_millis(1100);
     REQUIRE(test_sink->flush_counter() == 1);
-    spdlog::flush_every(std::chrono::seconds(0));
+    spdlog::flush_every(spdlog::chrono::seconds(0));
     spdlog::drop_all();
 }

tests/test_sink.h

@@ -5,12 +5,9 @@
 
 #pragma once
 
-#include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/base_sink.h"
+#include "spdlog/details/null_mutex.h"
 
-#include <chrono>
-#include <mutex>
-#include <thread>
 
 namespace spdlog {
 namespace sinks {
@@ -29,7 +26,7 @@ public:
         return flush_counter_;
     }
 
-    void set_delay(std::chrono::milliseconds delay)
+    void set_delay(spdlog::chrono::milliseconds delay)
     {
         delay_ = delay;
     }
@@ -38,7 +35,7 @@ protected:
     void sink_it_(const details::log_msg &) override
     {
         msg_counter_++;
-        std::this_thread::sleep_for(delay_);
+        spdlog::details::os::sleep_for_millis(delay_.count());
     }
 
     void flush_() override
@@ -47,10 +44,10 @@ protected:
     }
     size_t msg_counter_{0};
     size_t flush_counter_{0};
-    std::chrono::milliseconds delay_{std::chrono::milliseconds::zero()};
+    spdlog::chrono::milliseconds delay_{spdlog::chrono::milliseconds::zero()};
 };
 
-using test_sink_mt = test_sink<std::mutex>;
+using test_sink_mt = test_sink<spdlog::mutex>;
 using test_sink_st = test_sink<details::null_mutex>;
 
 } // namespace sinks